Strict Standards: Non-static method utf_normalizer::nfc() should not be called statically in /www/htdocs/w006661d/anddev/includes/utf/utf_tools.php on line 1781
[phpBB Debug] PHP Notice: in file /bbc_download.php on line 73: Cannot modify header information - headers already sent by (output started at /includes/utf/utf_tools.php:1781)
[phpBB Debug] PHP Notice: in file /bbc_download.php on line 74: Cannot modify header information - headers already sent by (output started at /includes/utf/utf_tools.php:1781)
[phpBB Debug] PHP Notice: in file /bbc_download.php on line 75: Cannot modify header information - headers already sent by (output started at /includes/utf/utf_tools.php:1781)
[phpBB Debug] PHP Notice: in file /bbc_download.php on line 76: Cannot modify header information - headers already sent by (output started at /includes/utf/utf_tools.php:1781)
[phpBB Debug] PHP Notice: in file /bbc_download.php on line 77: Cannot modify header information - headers already sent by (output started at /includes/utf/utf_tools.php:1781)
[phpBB Debug] PHP Notice: in file /bbc_download.php on line 78: Cannot modify header information - headers already sent by (output started at /includes/utf/utf_tools.php:1781)
package org.anddev.android.threedcolorobjects; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.nio.IntBuffer; import javax.microedition.khronos.opengles.GL10; import android.app.Activity; import android.content.Context; import android.graphics.Canvas; import android.graphics.OpenGLContext; import android.graphics.PixelFormat; import android.os.Bundle; import android.os.Handler; import android.os.Message; import android.os.SystemClock; import android.util.AttributeSet; import android.view.SurfaceHolder; import android.view.SurfaceView; import android.view.View; import java.util.Map; /** * Example of how to use OpenGL|ES in a custom view * */ public class GLView extends SurfaceView implements SurfaceHolder.Callback{ SurfaceHolder mHolder; private GLThread mGLThread; private ThreeDObject mThreeDObj; private float mAngle; private long mNextTime; private boolean mAnimate, mHasSurface; /** * The View constructor is a good place to allocate our OpenGL context */ public GLView(Context context) { super(context); /* * Create an OpenGL|ES context. This must be done only once, an * OpenGL contex is a somewhat heavy object. */ init(); } public GLView(Context context, AttributeSet attrs, Map inflateParams) { super(context, attrs, inflateParams); init(); } private void init() { // Install a SurfaceHolder.Callback so we get notified when the // underlying surface is created and destroyed mHolder = getHolder(); mHolder.addCallback(this); } public void surfaceCreated(SurfaceHolder holder) { // The Surface has been created, start our drawing thread. mGLThread = new GLThread(); mGLThread.start(); } public void surfaceDestroyed(SurfaceHolder holder) { // Surface will be destroyed when we return mGLThread.requestExitAndWait(); mGLThread = null; } public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) { // Surface size or format has changed. This should not happen in this // example. mGLThread.onWindowResize(w, h); } class GLThread extends Thread { private boolean mDone; private int mWidth; private int mHeight; GLThread() { super(); mDone = false; mWidth = 0; mHeight = 0; mThreeDObj = new Pyramid(); } @Override public void run() { /* * First, we need to get to the appropriate GL interface. * This is simply done by casting the GL context to either * GL10 or GL11. */ OpenGLContext mGLContext = new OpenGLContext( OpenGLContext.DEPTH_BUFFER); SurfaceHolder holder = mHolder; mGLContext.makeCurrent(holder); GL10 gl = (GL10) (mGLContext.getGL()); gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_FASTEST); while (!mDone) { int w,h; synchronized(this){ w= getWidth(); h = getHeight(); } /* * Set the viewport. This doesn't have to be done each time * draw() is called. Typically this is called when the view * is resized. */ gl.glViewport(0, 0, w, h); /* * Set our projection matrix. This doesn't have to be done * each time we draw, but usualy a new projection needs to be set * when the viewport is resized. */ float ratio = (float) w / h; gl.glMatrixMode(gl.GL_PROJECTION); gl.glLoadIdentity(); gl.glFrustumf(-ratio, ratio, -1, 1, 2, 12); /* * dithering is enabled by default in OpenGL, unfortunattely * it has a significant impact on performace in software * implementation. Often, it's better to just turn it off. */ gl.glDisable(gl.GL_DITHER); /* * Usually, the first thing one might want to do is to clear * the screen. The most efficient way of doing this is to use * glClear(). However we must make sure to set the scissor * correctly first. The scissor is always specified in window * coordinates: */ gl.glClearColor(1, 1, 1, 1); gl.glEnable(gl.GL_SCISSOR_TEST); gl.glScissor(0, 0, w, h); gl.glClear(gl.GL_COLOR_BUFFER_BIT); /* * Now we're ready to draw some 3D object */ gl.glMatrixMode(gl.GL_MODELVIEW); gl.glLoadIdentity(); gl.glTranslatef(0, 0, -3.0f); gl.glScalef(0.5f, 0.5f, 0.5f); gl.glRotatef(mAngle, 0, 1, 0); gl.glRotatef(mAngle * 0.25f, 1, 0, 0); gl.glColor4f(0.7f, 0.7f, 0.7f, 1.0f); gl.glEnableClientState(gl.GL_VERTEX_ARRAY); gl.glEnableClientState(gl.GL_COLOR_ARRAY); gl.glEnable(gl.GL_CULL_FACE); mThreeDObj.draw(gl); mAngle += 1.2f; /* * Once we're done with GL, we need to flush all GL commands and * make sure they complete before we can issue more native * drawing commands. This is done by calling waitGL(). */ //mGLContext.waitGL(); mGLContext.post(); } } public void onWindowResize(int w, int h) { synchronized(this) { mWidth = w; mHeight = h; } } public void requestExitAndWait() { // don't call this from GLThread thread or it a guaranteed // deadlock! mDone = true; try { join(); } catch (InterruptedException ex) { } } } } abstract class ThreeDObject{ public abstract void draw(GL10 gl); } class Cube extends ThreeDObject{ private IntBuffer mVertexBuffer; private IntBuffer mColorBuffer; private ByteBuffer mIndexBuffer; public Cube() { int one = 0x10000; /* Every vertex got 3 values, for * x / y / z position in the kartesian space. */ int vertices[] = { -one, -one, -one, one, -one, -one, one, one, -one, -one, one, -one, -one, -one, one, one, -one, one, one, one, one, -one, one, one, }; /* Every vertex has got its own color, described by 4 values * R(ed) * G(green) * B(blue) * A(lpha) <-- Opticacy */ int colors[] = { 0, 0, 0, one, one, 0, 0, one, one, one, 0, one, 0, one, 0, one, 0, 0, one, one, one, 0, one, one, one, one, one, one, 0, one, one, one, }; /* The last thing is that we need to describe some Triangles. * A triangle got 3 vertices. * The confusing thing is, that it is important in which order * the vertices of each triangle are described. * So describing a triangle through the vertices: "0, 3, 4" * will not result in the same triangle as: "0, 4, 3" * You probably ask: Why the hell isn't that the same ??? * The reason for that is the call of: "gl.glFrontFace(gl.GL_CW);" * which means, that we have to describe the "visible" side of the * triangles by naming its vertices in a ClockWise order! * From the other side, the triangle will be 100% lookthru! * You can create a kind of magic mirror with that . */ byte indices[] = { 0, 4, 5, 0, 5, 1, 1, 5, 6, 1, 6, 2, 2, 6, 7, 2, 7, 3, 3, 7, 4, 3, 4, 0, 4, 7, 6, 4, 6, 5, 3, 0, 1, 3, 1, 2 }; // Buffers to be passed to gl*Pointer() functions // must be direct, i.e., they must be placed on the // native heap where the garbage collector cannot // move them. // // Buffers with multi-byte datatypes (e.g., short, int, float) // must have their byte order set to native order ByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length * 4); // * 4 becuase of int vbb.order(ByteOrder.nativeOrder()); mVertexBuffer = vbb.asIntBuffer(); mVertexBuffer.put(vertices); mVertexBuffer.position(0); ByteBuffer cbb = ByteBuffer.allocateDirect(colors.length * 4); // * 4 becuase of int cbb.order(ByteOrder.nativeOrder()); mColorBuffer = cbb.asIntBuffer(); mColorBuffer.put(colors); mColorBuffer.position(0); mIndexBuffer = ByteBuffer.allocateDirect(indices.length); mIndexBuffer.put(indices); mIndexBuffer.position(0); } public void draw(GL10 gl) { gl.glFrontFace(gl.GL_CW); gl.glVertexPointer(3, gl.GL_FIXED, 0, mVertexBuffer); gl.glColorPointer(4, gl.GL_FIXED, 0, mColorBuffer); gl.glDrawElements(gl.GL_TRIANGLES, 36, gl.GL_UNSIGNED_BYTE, mIndexBuffer); } } class Pyramid extends ThreeDObject{ private IntBuffer mVertexBuffer; private IntBuffer mColorBuffer; private ByteBuffer mIndexBuffer; public Pyramid() { int one = 0x10000; /* Every vertex got 3 values, for * x / y / z position in the kartesian space. */ int vertices[] = { -one, -one, -one, // The four floor vertices of the pyramid one, -one, -one, one, one, -one, -one, one, -one, 0, 0, one, }; // The top of the pyramid /* Every vertex has got its own color, described by 4 values * R(ed) * G(green) * B(blue) * A(lpha) <-- Opticacy */ int colors[] = { 0, 0, one, one, one, 0, 0, one, one, one, 0, one, 0, one, 0, one, one, 0, one, one, }; /* The last thing is that we need to describe some Triangles. * A triangle got 3 vertices. * The confusing thing is, that it is important in which order * the vertices of each triangle are described. * So describing a triangle through the vertices: "0, 3, 4" * will not result in the same triangle as: "0, 4, 3" * You probably ask: Why the hell isn't that the same ??? * The reason for that is the call of: "gl.glFrontFace(gl.GL_CW);" * which means, that we have to describe the "visible" side of the * triangles by naming its vertices in a ClockWise order! * From the other side, the triangle will be 100% lookthru! * You can create a kind of magic mirror with that . */ byte indices[] = { 0, 4, 1, // The four side-triangles 1, 4, 2, 2, 4, 3, 3, 4, 0, 1, 2, 0, // The two bottom-triangles 0, 2, 3}; // Buffers to be passed to gl*Pointer() functions // must be direct, i.e., they must be placed on the // native heap where the garbage collector cannot // move them. // // Buffers with multi-byte datatypes (e.g., short, int, float) // must have their byte order set to native order ByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length * 4); // * 4 becuase of int vbb.order(ByteOrder.nativeOrder()); mVertexBuffer = vbb.asIntBuffer(); mVertexBuffer.put(vertices); mVertexBuffer.position(0); ByteBuffer cbb = ByteBuffer.allocateDirect(colors.length * 4); // * 4 becuase of int cbb.order(ByteOrder.nativeOrder()); mColorBuffer = cbb.asIntBuffer(); mColorBuffer.put(colors); mColorBuffer.position(0); mIndexBuffer = ByteBuffer.allocateDirect(indices.length); mIndexBuffer.put(indices); mIndexBuffer.position(0); } public void draw(GL10 gl) { gl.glFrontFace(gl.GL_CW); gl.glVertexPointer(3, gl.GL_FIXED, 0, mVertexBuffer); gl.glColorPointer(4, gl.GL_FIXED, 0, mColorBuffer); gl.glDrawElements(gl.GL_TRIANGLES, 18, gl.GL_UNSIGNED_BYTE, mIndexBuffer); } }