@Test public void testClassBreaks() throws Exception { Renderer renderer = parseAndConvertToRenderer("earthquakes.sld"); assertTrue(renderer.toString(), renderer instanceof ClassBreaksRenderer); renderer = parseAndConvertToRenderer("hnd_bridges_graduated.sld"); assertTrue(renderer.toString(), renderer instanceof ClassBreaksRenderer); }
/** * Returns the location in world space of the point (x, y) on the screen. * * @param x x coordinate in the image * @param y y coordinate in the image * @return true if there is an object at x, y , false otherwise */ public boolean getPoint(int x, int y, double xyz[]) { if (renderer.bufferg == false) { renderer.bufferg = true; isDamage = true; } return renderer.getPoint(x, y, xyz); }
@Override public void onDraw(Canvas canvas) { super.onDraw(canvas); int count = mPagesCount; if (count == 0) { return; } float cx = canvas.getWidth() >> 1; float cy = canvas.getHeight() >> 1; int totalCount = 2 * count - 1; int halfCount = totalCount / 2; float itemWithOffset = mIndicatorElementSize + mIndicatorElementSpacing; float halfItemWithOffset = mIndicatorElementSize / 2 + mIndicatorElementSpacing; float halfSize = mIndicatorElementSize / 2f; float halfSpacing = mIndicatorElementSpacing / 2f; float startX = cx - halfCount * (mIndicatorElementSize + mIndicatorElementSpacing); float top = cy - halfSize; float bottom = cy + halfSize; // if we have odd elements - need to set indicators in center if (totalCount % 2 != 0) { startX -= halfSize + halfSpacing; } int i; for (i = 0; i < totalCount; i++) { // skip empty spaces if (i % 2 != 0) { continue; } float left = startX + (mIndicatorElementSize + mIndicatorElementSpacing) * i; float right = left + mIndicatorElementSize; mElementBounds.set(left, top, right, bottom); mRenderer.draw(canvas, mElementBounds, mIndicatorPaint, false); } // multiply on 2 because there are spaces between elements float activeItemOffset = (mSelectedPosition + mScrolledOffset) * 2; float left = startX + (mIndicatorElementSize + mIndicatorElementSpacing) * activeItemOffset; float right = left + mIndicatorElementSize; mElementBounds.set(left, top, right, bottom); canvas.clipRect(mClipBounds); canvas.save(); canvas.rotate(ANGLE_360 * mScrolledOffset, mElementBounds.centerX(), mElementBounds.centerY()); mRenderer.draw(canvas, mElementBounds, mIndicatorSelectedPaint, true); canvas.restore(); if (mIsInfiniteScroll && mSelectedPosition == mPagesCount - 1) { // isInfinite && isEnd activeItemOffset = (1f - mScrolledOffset) * 2; left = mClipBounds.left - itemWithOffset * activeItemOffset + halfItemWithOffset; right = left + mIndicatorElementSize; mElementBounds.set(left, top, right, bottom); canvas.save(); canvas.rotate( ANGLE_360 * mScrolledOffset, mElementBounds.centerX(), mElementBounds.centerY()); mRenderer.draw(canvas, mElementBounds, mIndicatorSelectedPaint, true); canvas.restore(); } }
@Override public void render(GraphNode resource, GraphNode context, String mode, OutputStream os) throws IOException { Renderer renderer = manager.createRenderer(resource, mode, mediaTypeList); if (renderer == null) { throw new RuntimeException( "no renderer could be created for " + resource + " (in " + resource.getNodeContext() + "), " + mode + "," + mediaTypeList); } renderer.render( resource, context, mode, uriInfo, requestHeaders, responseHeaders, sharedRenderingValue, os); }
/** * renders a filter on a fullscreen quad * * @param r * @param buff * @param mat */ private void renderProcessing(Renderer r, FrameBuffer buff, Material mat) { if (buff == outputBuffer) { fsQuad.setWidth(width); fsQuad.setHeight(height); filterCam.resize(originalWidth, originalHeight, true); fsQuad.setPosition(left * originalWidth, bottom * originalHeight); } else { fsQuad.setWidth(buff.getWidth()); fsQuad.setHeight(buff.getHeight()); filterCam.resize(buff.getWidth(), buff.getHeight(), true); fsQuad.setPosition(0, 0); } if (mat.getAdditionalRenderState().isDepthWrite()) { mat.getAdditionalRenderState().setDepthTest(false); mat.getAdditionalRenderState().setDepthWrite(false); } fsQuad.setMaterial(mat); fsQuad.updateGeometricState(); renderManager.setCamera(filterCam, true); r.setFrameBuffer(buff); r.clearBuffers(false, true, true); renderManager.renderGeometry(fsQuad); }
/** main renderer */ public void run() { // MEASURE ELAPSED TIME AND FRAMERATE elapsed += getCurrentTime() - currentTime; currentTime = getCurrentTime(); if (isDamage) { frameRate = .9 * frameRate + .1 / elapsed; elapsed = 0; // LET THE APPLICATION PROGRAMMER MOVE THINGS INTO PLACE identity(); // APPLIC. MATRIX STARTS UNTRANSFORMED // isDamage = true; renderer.rotateView(theta, phi); theta = phi = 0; ianimate(currentTime - startTime); // APPLICATION ANIMATES THINGS // SHADE AND SCAN CONVERT GEOMETRY INTO FRAME BUFFER renderer.refresh(); renderer.render(); // KEEP REFINING LEVEL OF DETAIL UNTIL PERFECT (WHEN LOD=1) if (renderer.lod > 1) { isDamage = true; renderer.lod--; } } }
@Override public void render(float delta) { // TODO why does game crash Renderer renderer = worldView.getRenderer(); renderer.drawTerrain(); renderer.drawTargetAndSkydiver(); worldView.getStatusView().drawHud(); }
public void addRenderer(Renderer renderer) { mClients.add(renderer); renderer.setOverlay(this); if (renderer.handlesTouch()) { mTouchClients.add(0, renderer); } }
private void doUpdate() { if (restorePending) { return; // we will get called again // after the restore is // complete } canvas.stopRenderer(); canvas.setDoubleBufferEnable(doubleBufferAttr.getValue()); if (coordSysAttr.getValue()) { coordSwitch.setWhichChild(Switch.CHILD_ALL); } else { coordSwitch.setWhichChild(Switch.CHILD_NONE); } if (getAnnotationsAttr().getValue()) { staticBackAnnotationSwitch.setWhichChild(Switch.CHILD_ALL); dynamicBackAnnotationSwitch.setWhichChild(Switch.CHILD_ALL); staticFrontAnnotationSwitch.setWhichChild(Switch.CHILD_ALL); dynamicFrontAnnotationSwitch.setWhichChild(Switch.CHILD_ALL); } else { staticBackAnnotationSwitch.setWhichChild(Switch.CHILD_NONE); dynamicBackAnnotationSwitch.setWhichChild(Switch.CHILD_NONE); staticFrontAnnotationSwitch.setWhichChild(Switch.CHILD_NONE); dynamicFrontAnnotationSwitch.setWhichChild(Switch.CHILD_NONE); } if (perspectiveAttr.getValue()) { view.setProjectionPolicy(View.PERSPECTIVE_PROJECTION); } else { view.setProjectionPolicy(View.PARALLEL_PROJECTION); } if (renderer != renderers[rendererAttr.getValue()]) { // TODO: renderer.clear(); // TODO: handle gui try { System.out.println("Clearing Attached : VolRend-doUpdate()"); clearAttach(); } catch (Exception e) { e.printStackTrace(); } renderer = renderers[rendererAttr.getValue()]; renderer.attach(dynamicAttachGroup, staticAttachGroup); } try { renderer.update(); annotations.update(); } catch (Exception e) { e.printStackTrace(); } catch (OutOfMemoryError e) { JOptionPane.showMessageDialog( null, "Ran out of memory!", "Render Error", JOptionPane.ERROR_MESSAGE); } int newVolEditId; if ((newVolEditId = volume.update()) != volEditId) { updateCenter(volume.minCoord, volume.maxCoord); newVolEditId = volEditId; } eyePtChanged(); canvas.startRenderer(); }
@Override public void visit(Consumer<? super Renderer> consumer) { consumer.accept(this); for (Renderer c : content) { c.visit(consumer); } }
private void mainLoop() { long startTime = 0L; long endTime = 0L; long deltaTime = 0L; while (!Display.isCloseRequested()) { startTime = System.currentTimeMillis(); // Run the physics simulation if (useOpenCL) { clPhysics.doPhysics(particleCount, deltaTime); // Render Renderer.render(clPhysics.getCurrentPosBuffer(), particleCount); } else { normalPhysics.doPhysics(particles, boxWidth, boxHeight, deltaTime); // Render Renderer.render(particles); } // Update the display Display.update(); endTime = System.currentTimeMillis(); deltaTime = endTime - startTime; System.out.println(deltaTime); } }
@Override public void render(KTech kt, Renderer r) { manager.renderObjects(kt, r); // Do not edit or remove this line r.drawImage(title, 50, 50); r.drawString("Press Enter to start", 0xffffffff, 220, 300); }
/** Method called by Renderer to signal an update is needed. */ public void render(Renderer aren) { aren.pushModelMatrix(); aren.setOrientation(orientation, scale, position); for (int i = 0; i < cells.size(); i++) { ((Cell) cells.elementAt(i)).render(aren); } aren.popModelMatrix(); }
@Override public void transformChanged(int type, Transform3D xform) { renderer.transformChanged(type, xform); renderer.eyePtChanged(); annotations.eyePtChanged(); getScaleAttr().set(xform); getTranslationAttr().set(xform); getRotationAttr().set(xform); }
@Override public void layout(int left, int top, int right, int bottom) { adjustPosition(); super.layout(left, top, right, bottom); if (mClients == null) return; for (Renderer renderer : mClients) { renderer.layout(left, top, right, bottom); } }
private void initRenderer() { if (renderer3d) { nodeRenderer = new Renderer3D(); edgeRenderer = new Renderer3D(); } else { nodeRenderer = new Renderer2D(); edgeRenderer = new Renderer2D(); } nodeRenderer.initRenderer(model.getNodeFont()); edgeRenderer.initRenderer(model.getEdgeFont()); }
/** * Called by subclass to service a rendering request. If REASON_RENDER (and when * REASON_REPLACE/RESIZE triggers a render) this doesn't actually do rendering but returns true. * This prevents potentially lengthy rendering from blocking the requester. * * @return Whether calling subclass should perform a render. * @throws IOException */ protected synchronized boolean serviceRenderRequest() { boolean rendering = false; try { switch (mRenderReason) { case REASON_INIT: mWidth = getCurrentScreenWidth(); mHeight = getCurrentScreenHeight(); if (null != mRenderer) { mRenderer.initRendering(this, mWidth, mHeight); mReady = true; notifyAll(); rendering = true; } break; case REASON_DISPOSE: mReady = false; if (null != mRenderer) mRenderer.deleteRendering(this); break; case REASON_RESIZE: int w = getCurrentScreenWidth(); int h = getCurrentScreenHeight(); if (w != mWidth || h != mHeight) { mWidth = w; mHeight = h; if (null != mRenderer) { mRenderer.resizeRendering(this, w, h); rendering = mRendering; } } break; case REASON_RENDER: rendering = true; break; case REASON_REPLACE: if (null != mRenderer) mRenderer.replacingRenderer(this); mRenderer = mNewRenderer; mNewRenderer = null; if (null != mRenderer) { mRenderer.replacedRenderer(this); rendering = mRendering; } break; } mRendering = rendering; if (mRenderBlocking) { notifyAll(); mRenderBlocking = false; } } catch (Throwable e) { rendering = false; Log.e(TAG, "Exception in RenderContext", e); } return rendering; }
private void loop() { Timer timer = new Timer(); while (!renderer.shouldClose()) { while (timer.shouldUpdateGame()) { timer.update(); update(); } renderer.draw(); } }
public Rectangle getPositionBounds(InputEditorPosition position) { Renderer renderer = widget_.getEditor().getRenderer(); Position pos = ((AceInputEditorPosition) position).getValue(); ScreenCoordinates start = renderer.textToScreenCoordinates(pos.getRow(), pos.getColumn()); return new Rectangle( start.getPageX(), start.getPageY(), (int) Math.round(renderer.getCharacterWidth()), (int) (renderer.getLineHeight() * 0.8)); }
public Rectangle getCursorBounds() { Range range = getSession().getSelection().getRange(); Renderer renderer = widget_.getEditor().getRenderer(); ScreenCoordinates start = renderer.textToScreenCoordinates(range.getStart().getRow(), range.getStart().getColumn()); ScreenCoordinates end = renderer.textToScreenCoordinates(range.getEnd().getRow(), range.getEnd().getColumn()); return new Rectangle( start.getPageX(), start.getPageY(), end.getPageX() - start.getPageX(), renderer.getLineHeight()); }
@Override public void render(Renderer r) throws IOException { r.print("<tr"); if (mId != null) { r.print(" id=\"" + mId + "\""); } if (mStyle != null) { r.print(" class=\"" + mStyle + "\""); } r.println(">"); super.render(r); r.println("</tr>"); }
@Override public void draw(Canvas canvas) { super.draw(canvas); if (mClients == null) return; boolean redraw = false; for (Renderer renderer : mClients) { renderer.draw(canvas); redraw = redraw || ((OverlayRenderer) renderer).isVisible(); } if (redraw) { invalidate(); } }
/** Constructor: Sets up this panel and loads the images. */ public Engine() { addKeyListener(new Controller()); setBackground(Color.black); setPreferredSize(new Dimension(WIDTH, HEIGHT)); setFocusable(true); // init world final int defWidth = 150; final int defHeight = 15; final Random gen = new Random(); // 50% random, 25% hills, 25% platform if (gen.nextBoolean()) { world = RandomLevel.genWorldRandom(defWidth, defHeight, tp); } else { if (gen.nextBoolean()) { world = RandomLevel.genWorldHills(defWidth, defHeight, tp); } else { world = RandomLevel.genWorldPlatform(defWidth, defHeight, tp); } } // world = new Level("house.txt", tp); // init hero hero = new Hero(); hero.setImage(tp.get(Texture.hero)); hero.setPos(world.getStart()); renderer.addDynProp(hero); renderer.setWorld(world); // init test light Point[] bgLights = world.getAll(Texture.bgLightDead); Light tempLight; final int cso = 15; // Cell size offset. final int rRange = 100; final int rMin = 75; for (Point light : bgLights) { tempLight = new Light(light.x + cso, light.y + cso, world); tempLight.setRadius((short) (Math.random() * rRange + rMin)); renderer.addStaticProp(tempLight); triggers.add(tempLight); } // Don't start this loop until setup is complete! if (thread == null) { running = true; thread = new Thread(this); thread.start(); } }
private void clearTrajectories() { synchronized (trajectoriesLock) { trajectories.clear(); } renderer.getTrajectoriesTableModel().removeAllElements(); currentTrajectory = new Trajectory(ColorGenerator.getInstance().current()); if (!gameOver) { currentTrajectory.addPoint(ball.getPosition()); synchronized (trajectoriesLock) { trajectories.add(currentTrajectory); } renderer.getTrajectoriesTableModel().addElement(currentTrajectory); } }
@Override public void render(Renderer r) throws IOException { r.println("<thead>"); r.println("<tr>"); for (Column c : mColumns) { String title = ""; if (c.hint != null) { title = " title=\"" + c.hint + "\""; } r.println("<th" + title + ">" + c.title + "</th>"); } r.println("</tr>"); r.println("</thead>"); }
@Override public boolean onTouchEvent(MotionEvent evt) { if (mTouchTarget != null) { return mTouchTarget.onTouchEvent(evt); } if (mTouchClients != null) { boolean res = false; for (Renderer client : mTouchClients) { res |= client.onTouchEvent(evt); } return res; } return false; }
/** Disposes of image memory and associated objects. */ public void disposeLocal() { m_aafBox = null; m_aafM = null; m_afShear = null; m_afOffset = null; m_afA = null; m_afB = null; m_aiSliceBound = null; m_aiBound = null; m_aiSliceMin = null; m_aiSliceMax = null; m_aiClipMin = null; m_aiClipMax = null; m_aaaasEncode = null; m_aaasVolumeEncode = null; m_aasSliceEncode = null; m_aaiIndex = null; m_asSkip = null; m_aiCurrentI = null; m_aiInterC = null; m_kP00 = null; m_kP01 = null; m_kP10 = null; m_kP11 = null; m_kPosition = null; super.disposeLocal(); System.gc(); }
/** * Listens for mouse release and controls aspects of the renderer. A release in the upper left * corner toggles {@link Renderer#tableMode}. A release in the upper right corner toggle * visibility of the {@link Material#table}display. When true, the current material table is * displayed in the upper left corner of the window. Position of the mouse determines current * material. A release in the lower right toggles {@link Renderer#showMesh} * * @param event Event * @param x current x coordinate * @param y current y coordinate * @return true */ public boolean mouseUp(int x, int y) { Renderer.setDragging(false); if (x < 35 && y < 35) { Renderer.tableMode = !Renderer.tableMode; } if (x > W - 35 && y < 35) { seeMaterial = !seeMaterial; renderer.bufferg = !renderer.bufferg; damage(); } if (x > W - 35 && y > H - 35) { renderer.showMesh = !renderer.showMesh; damage(); } return true; }
/** * Draws everything onto the main panel. * * @param page Graphics component to draw on */ public void paintComponent(Graphics page) { super.paintComponent(page); setForeground(Color.cyan); renderer.draw(page, this, offX, offY); // hero.draw(this, page, offX, offY); for (Entity effect : effects) { effect.draw(this, page, offX, offY); /*if (effect instanceof Burst) { Burst pop = (Burst) effect; pop.draw(this, page, offX, offY); }*/ } // Draw hero position information Rectangle r = hero.getBounds(); page.drawString("Position: x = " + (r.x + (r.width >> 1)), SCORE_PLACE_X, SCORE_PLACE_Y); final int tab = 100; final int lineHeight = 20; page.drawString("y = " + (r.y + (r.height >> 1)), SCORE_PLACE_X + tab, SCORE_PLACE_Y); page.drawString("Frame: " + frame, SCORE_PLACE_X, SCORE_PLACE_Y + lineHeight); if (!running) { page.drawString("Game over :(", WIDTH / 2, HEIGHT / 2); } }
public static void main(String[] args) throws LWJGLException, FileNotFoundException { App app = new App(); app.loadNatives(SupportedPlatform.getPlatformForOS()); clPhysics = new CLPhysics(); normalPhysics = new NormalPhysics(); // Init OpenGL app.initializeOpenGL(); Renderer.initOpenGL(boxWidth, boxHeight); // Prepare data app.particles = app.prepareData(); // Init OpenCL if (useOpenCL) { clPhysics.initializeCLPhysics(app.particles); } // Loop and run simulation until window is closed app.mainLoop(); // Clean up OpenCL if (useOpenCL) { clPhysics.cleanupCLPhysics(); } // Clean up OpenGL app.cleanupOpenGL(); }