@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();
}
