static void drawModels(float zScale) { const int translationScale = 9; int x, y; seedRandom(9); //glScalex(1 << 16, 1 << 16, (GLfixed)(zScale * 65536)); for (y = -5; y <= 5; ++y) { for (x = -5; x <= 5; ++x) { float buildingScale; GLfixed fixedScale; int curShape = randomUInt() % SUPERSHAPE_COUNT; buildingScale = sSuperShapeParams[curShape][SUPERSHAPE_PARAMS - 1]; fixedScale = (GLfixed)(buildingScale * 65536); #if 0 glPushMatrix(); glTranslatex((x * translationScale) * 65536, (y * translationScale) * 65536, 0); glRotatex((GLfixed)((randomUInt() % 360) << 16), 0, 0, 1 << 16); glScalex(fixedScale, fixedScale, fixedScale); drawGLObject(sSuperShapeObjects[curShape]); glPopMatrix(); #endif } } for (x = -2; x <= 2; ++x) { const int shipScale100 = translationScale * 500; const int offs100 = x * shipScale100 + (sTick % shipScale100); float offs = offs100 * 0.01f; GLfixed fixedOffs = (GLfixed)(offs * 65536); #if 0 glPushMatrix(); glTranslatex(fixedOffs, -4 * 65536, 2 << 16); drawGLObject(sSuperShapeObjects[SUPERSHAPE_COUNT - 1]); glPopMatrix(); glPushMatrix(); glTranslatex(-4 * 65536, fixedOffs, 4 << 16); glRotatex(90 << 16, 0, 0, 1 << 16); drawGLObject(sSuperShapeObjects[SUPERSHAPE_COUNT - 1]); glPopMatrix(); #endif } }
void FGAPIENTRY glutStrokeString(void* fontID, const char *string) { int c, i; int numchar = (int)strlen((char*) string); GLfixed length = 0; GLbyte indices[255]; SFG_StrokeFont* font = fghStrokeByID(fontID); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); glEnableClientState (GL_VERTEX_ARRAY); for(i = 0; i < 255; i++) indices[i] = i; /* * Step through the string, drawing each character. * A newline will simply translate the next character's insertion * point back to the start of the line and down one line. */ for(c = 0; c < numchar; c++) if(string[ c ] < font->Quantity) { if(string[ c ] == '\n') { glTranslatex(-length, -font->Height, 0); length = 0; } else /* Not an EOL, draw the bitmap character */ { const SFG_StrokeChar *schar = font->Characters[ string[ c ] ]; if(schar) { const SFG_StrokeStrip *strip = schar->Strips; for(i = 0; i < schar->Number; i++, strip++) { glVertexPointer(2, GL_FIXED, 0, strip->Vertices); glDrawElements(GL_LINE_STRIP, strip->Number, GL_UNSIGNED_BYTE, indices); } length += schar->Right; glTranslatex(schar->Right, 0, 0); } } } }
void Camera::Update() { Vector3 f = m_center - m_eye; //normalize it //int test = XTOF(f.z); int mag = sqrtx( (int32)(MULX(f.x,f.x) + (int32)MULX(f.y,f.y) + (int32)MULX(f.z,f.z)) ); int n = DIVX(ITOX(1),mag); f.x = MULX(f.x,n); f.y = MULX(f.y,n); f.z = MULX(f.z,n); //update direction m_dir = f; Vector3 s = f ^ m_up, u = s ^ f; int matrix[16] = { s.x, u.x, -f.x, 0, s.y, u.y, -f.y, 0, s.z, u.z, -f.z, 0, 0, 0, 0, ITOX(1) }; glMultMatrixx(matrix); glTranslatex(-m_eye.x,-m_eye.y,-m_eye.z); }
SubCanvas(Canvas &canvas, RasterPoint _offset, PixelSize _size) #ifdef ENABLE_OPENGL :relative(_offset) #endif { #ifdef ENABLE_OPENGL assert(canvas.offset == OpenGL::translate); #else surface = canvas.surface; #endif offset = canvas.offset + _offset; size = _size; #ifdef ENABLE_OPENGL if (relative.x != 0 || relative.y != 0) { OpenGL::translate += _offset; glPushMatrix(); #ifdef HAVE_GLES glTranslatex((GLfixed)relative.x << 16, (GLfixed)relative.y << 16, 0); #else glTranslatef(relative.x, relative.y, 0); #endif } #endif }
SubCanvas::SubCanvas(Canvas &canvas, RasterPoint _offset, PixelSize _size) :relative(_offset) { assert(canvas.offset == OpenGL::translate); offset = canvas.offset + _offset; /* sub canvas bottom right limits can't be outside "parent" canvas. */ size.cx = std::min<PixelScalar>(_size.cx, canvas.GetSize().cx - _offset.x) ; size.cy = std::min<PixelScalar>(_size.cy, canvas.GetSize().cy - _offset.y) ; if (relative.x != 0 || relative.y != 0) { OpenGL::translate += _offset; #ifdef USE_GLSL glVertexAttrib4f(OpenGL::Attribute::TRANSLATE, OpenGL::translate.x, OpenGL::translate.y, 0, 0); #else glPushMatrix(); #ifdef HAVE_GLES glTranslatex((GLfixed)relative.x << 16, (GLfixed)relative.y << 16, 0); #else glTranslatef(relative.x, relative.y, 0); #endif #endif /* !USE_GLSL */ } if ((relative.x + size.cx < canvas.GetSize().cx) || (relative.y + size.cy < canvas.GetSize().cy)) { /* Enable Clipping */ push_scissor = std::make_unique<GLPushScissor>(); scissor = std::make_unique<GLCanvasScissor>(*this); } }
void ApplyProjection(const WindowProjection &projection, const GeoPoint &reference) { fixed angle = projection.GetScreenAngle().Degrees(); fixed scale = projection.GetScale(); const RasterPoint &screen_origin = projection.GetScreenOrigin(); const GeoPoint &screen_location = projection.GetGeoLocation(); const GeoPoint projection_delta = reference - screen_location; const fixed scale_r = scale * FAISphere::REARTH; const fixed scale_x = scale_r * screen_location.latitude.fastcosine(); const fixed scale_y = -scale_r; #ifdef HAVE_GLES #ifdef FIXED_MATH GLfixed fixed_angle = angle.as_glfixed(); #else GLfixed fixed_angle = angle * (1<<16); #endif glTranslatex((int)screen_origin.x << 16, (int)screen_origin.y << 16, 0); glRotatex(fixed_angle, 0, 0, -(1<<16)); #else glTranslatef(screen_origin.x, screen_origin.y, 0.); glRotatef((GLfloat)angle, 0., 0., -1.); #endif glScalef(GLfloat(scale_x), GLfloat(scale_y), 1.); glTranslatef(GLfloat(projection_delta.longitude.Native()), GLfloat(projection_delta.latitude.Native()), 0.); }
//---------------------------------------------------------------------------- void Render() { static int rotation = 0; /* Vertex 1 Vertex 2 Vertex 3*/ GLshort vertexArray[9] = {-25,-25,0, 25,-25,0, 0,25,0 }; GLubyte colorArray[12] = {255,0,0,0, 0,255,0,0, 0,0,255,0}; glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glLoadIdentity(); glTranslatex(0, 0, FixedFromInt(-10)); glRotatex(FixedFromInt(rotation++), 0, ONE,0); //Enable the vertices array glEnableClientState(GL_VERTEX_ARRAY); glVertexPointer(3, GL_SHORT, 0, vertexArray); //3 = XYZ coordinates, GL_SHORT = data type, 0 = 0 stride bytes //Enable the vertex color array glEnableClientState(GL_COLOR_ARRAY); glColorPointer(4,GL_UNSIGNED_BYTE, 0, colorArray); //4 = RGBA format, GL_UNSIGNED_BYTE = data type,0=0 stide bytes glDrawArrays(GL_TRIANGLES, 0, 3); /*We want draw triangles, 0 = first element(vertice), 3 = number of items (vertices) to draw from the array*/ glDisableClientState(GL_VERTEX_ARRAY); glDisableClientState(GL_COLOR_ARRAY); eglSwapBuffers(glesDisplay, glesSurface); }
// Draws a char on screen using embedded line font, (x, y) are center of char, not upper-left corner // TODO: use SDL 1.3 renderer routines? It will not be pixel-aligned then, if the screen is resized static inline void drawCharWireframe(int idx, Uint16 x, Uint16 y, int rotation, Uint8 r, Uint8 g, Uint8 b, Uint8 a) { glColor4x(r * 0x100, g * 0x100, b * 0x100, a * 0x100); glVertexPointer(2, GL_SHORT, 0, fontGL[idx]); glPopMatrix(); glPushMatrix(); glTranslatex( x * 0x10000, y * 0x10000, 0 ); if(rotation != 0) glRotatex( rotation, 0, 0, 0x10000 ); glDrawArrays(GL_LINES, 0, fontGL[idx][FONT_CHAR_LINES_COUNT]); }
void CSimpleCubePbuffer::AppCycle( TInt aFrame ) { glClear( GL_COLOR_BUFFER_BIT ); // Animate and draw box glLoadIdentity(); glTranslatex( 0 , 0 , -cameraDistance << 16 ); glRotatex( aFrame << 16, 1 << 16, 0 , 0 ); glRotatex( aFrame << 15, 0 , 1 << 16, 0 ); glRotatex( aFrame << 14, 0 , 0 , 1 << 16 ); DrawBox( 15.f, 15.f, 15.f ); }
void FGAPIENTRY glutBitmapCharacterPoints(void* fontID, int x, int y, int character) { const GLubyte* face; SFG_Font* font = fghFontByID(fontID); if(!font) return; if(!(character >= 1)&&(character < 256)) return; face = font->Characters[ character - 1 ]; glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glOrthox(0, _INT2FIXED(fgStructure.Window->State.Width), 0, _INT2FIXED(fgStructure.Window->State.Height), 0, _INT2FIXED(1)); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glDisable(GL_DEPTH_TEST); glTranslatex(_INT2FIXED(x), _INT2FIXED(y), 0); __glutBitmapCharacter(font, character); glTranslatex(_INT2FIXED(face[0]), 0, 0); glEnable(GL_DEPTH_TEST); glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(GL_MODELVIEW); glPopMatrix(); }
void Canvas::DrawPolyline(const RasterPoint *points, unsigned num_points) { #ifdef USE_GLSL glm::mat4 matrix = glm::translate(glm::mat4(),glm::vec3(1, 1, 0)); glUniformMatrix4fv(OpenGL::solid_modelview, 1, GL_FALSE, glm::value_ptr(matrix)); #else glPushMatrix(); #ifdef HAVE_GLES glTranslatex((GLfixed)1 << 16, (GLfixed)1 << 16, 0); #else glTranslatef(1, 1, 0.); #endif #endif #ifdef USE_GLSL OpenGL::solid_shader->Use(); #endif pen.Bind(); if (pen.GetWidth() <= 2) { const ScopeVertexPointer vp(points); glDrawArrays(GL_LINE_STRIP, 0, num_points); } else { const unsigned vertices = LineToTriangles(points, num_points, vertex_buffer, pen.GetWidth(), false); if (vertices > 0) { const ScopeVertexPointer vp(vertex_buffer.begin()); glDrawArrays(GL_TRIANGLE_STRIP, 0, vertices); } } pen.Unbind(); #ifdef USE_GLSL glUniformMatrix4fv(OpenGL::solid_modelview, 1, GL_FALSE, glm::value_ptr(glm::mat4())); #else glPopMatrix(); #endif }
CanvasRotateShift(const RasterPoint pos, Angle angle, const int scale = 100) { #ifdef USE_GLSL glm::mat4 matrix = glm::rotate(glm::translate(glm::mat4(), glm::vec3(pos.x, pos.y, 0)), GLfloat(angle.Degrees()), glm::vec3(0, 0, 1)); float gl_scale = scale / 100.f; if (Layout::ScaleSupported()) gl_scale *= Layout::scale_1024 / 1024.f; matrix = glm::scale(matrix, glm::vec3(gl_scale)); glUniformMatrix4fv(OpenGL::solid_modelview, 1, GL_FALSE, glm::value_ptr(matrix)); #else glPushMatrix(); #ifdef HAVE_GLES glTranslatex((GLfixed)pos.x << 16, (GLfixed)pos.y << 16, 0); GLfixed fixed_angle = angle.Degrees() * (1<<16); glRotatex(fixed_angle, 0, 0, 1<<16); #else glTranslatef(pos.x, pos.y, 0.); glRotatef((GLfloat)angle.Degrees(), 0., 0., 1.); #endif #ifdef HAVE_GLES GLfixed gl_scale = ((GLfixed) scale << 16) / 100; if (Layout::ScaleSupported()) gl_scale = (gl_scale * Layout::scale_1024) >> 10; glScalex(gl_scale, gl_scale, (GLfixed)1 << 16); #else float gl_scale = scale / 100.f; if (Layout::ScaleSupported()) gl_scale *= Layout::scale_1024 / 1024.f; glScalef(gl_scale, gl_scale, 1.); #endif #endif /* USE_GLSL */ };
SubCanvas::SubCanvas(Canvas &canvas, RasterPoint _offset, PixelSize _size) :relative(_offset) { assert(canvas.offset == OpenGL::translate); offset = canvas.offset + _offset; size = _size; if (relative.x != 0 || relative.y != 0) { OpenGL::translate += _offset; #ifdef USE_GLSL glVertexAttrib4f(OpenGL::Attribute::TRANSLATE, OpenGL::translate.x, OpenGL::translate.y, 0, 0); #else glPushMatrix(); #ifdef HAVE_GLES glTranslatex((GLfixed)relative.x << 16, (GLfixed)relative.y << 16, 0); #else glTranslatef(relative.x, relative.y, 0); #endif #endif /* !USE_GLSL */ } }
/* * Draw a stroke character */ void FGAPIENTRY glutStrokeCharacter(void* fontID, int character) { const SFG_StrokeChar *schar; const SFG_StrokeStrip *strip; int i; SFG_StrokeFont* font = fghStrokeByID(fontID); GLbyte indices[255]; if(! (character >= 0) && (character < font->Quantity)) return; schar = font->Characters[ character ]; if(! schar) return; strip = schar->Strips; glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); glEnableClientState (GL_VERTEX_ARRAY); for(i = 0; i < 255; i++) indices[i] = i; for(i = 0; i < schar->Number; i++, strip++) { glVertexPointer(2, GL_FIXED, 0, strip->Vertices); glDrawElements(GL_LINE_STRIP, strip->Number, GL_UNSIGNED_BYTE, indices); } glTranslatex((GLfixed)schar->Right, 0, 0); }
void FGAPIENTRY glutBitmapStringPoints(void* fontID, int x, int y, const char *string) { SFG_Font* font = fghFontByID(fontID); int numchar, xx = 0, yy = 0, nbpoints = 0, i, c; GLshort *points; GLushort *indices; if(!font || !string) return; if(!string[0]) return; glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glOrthox(0, _INT2FIXED(fgStructure.Window->State.Width), 0, _INT2FIXED(fgStructure.Window->State.Height), 0, _INT2FIXED(1)); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glDisable(GL_DEPTH_TEST); glTranslatex(_INT2FIXED(x), _INT2FIXED(y), 0); numchar = (int)strlen((char*) string); points = (GLshort*)malloc(numchar * font->Height * (*(font->Characters[ 'X' - 1 ])) * 8 * sizeof(GLshort)); for(c = 0; c < numchar; c++) { if(string[c] == '\n') { yy -= font->Height; xx = 0; } else { const GLubyte* face = font->Characters[ string[c] - 1 ]; nbpoints += BitsToIndexedShorts(face+1, face[0], font->Height, points+(nbpoints*2), xx, yy); xx += face[0]; } } glEnable(GL_ALPHA_TEST); glAlphaFuncx(GL_NOTEQUAL, 0); indices = (GLushort*)malloc(nbpoints*sizeof(GLushort)); for(i = 0; i < nbpoints; i++) indices[i] = i; glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); glEnableClientState (GL_VERTEX_ARRAY); glVertexPointer(2, GL_SHORT, 0, points); glDrawElements(GL_POINTS, nbpoints, GL_UNSIGNED_SHORT, indices); glDisable(GL_ALPHA_TEST); free(indices); free(points); glEnable(GL_DEPTH_TEST); glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(GL_MODELVIEW); }
void FGAPIENTRY glutTrueTypeStringPoints(WCHAR *fontname, int fontsize, int style, int x, int y, const WCHAR *string) { int len, xx = 0, yy = 0, nbpoints = 0, i; GLshort *points; GLushort *indices; HFONT font; LOGFONTW lf; RECT rect; static HBITMAP bmp; static BYTE *img; static HDC hdc = NULL; static BITMAPINFO bi; SIZE sz; static EGLint width, height; if(!fontname || !string) return; if(!string[0]) return; // Initialize static DC and DIB bitmap on the first call if(!hdc) { // Create a device compatible DC hdc = CreateCompatibleDC(GetDC(fgStructure.Window->Window.Handle)); eglQuerySurface(fgDisplay.eglDisplay, fgStructure.Window->Window.Surface, EGL_WIDTH, &width); eglQuerySurface(fgDisplay.eglDisplay, fgStructure.Window->Window.Surface, EGL_HEIGHT, &height); // Create a DIB bitmap and attach it to the DC ZeroMemory(&bi, sizeof(BITMAPINFO)); bi.bmiHeader.biSize=sizeof(BITMAPINFOHEADER); bi.bmiHeader.biWidth = width; bi.bmiHeader.biHeight = height; bi.bmiHeader.biBitCount = 8; bi.bmiHeader.biPlanes = 1; bi.bmiHeader.biCompression = BI_RGB; bmp = CreateDIBSection(hdc, &bi, DIB_RGB_COLORS, &img, NULL, 0); SelectObject(hdc, bmp); SelectObject(hdc, GetStockObject(BLACK_BRUSH)); SetBkMode(hdc, TRANSPARENT); SetTextColor(hdc, RGB(255, 255, 255)); } // Erase DC content with the current black brush //Rectangle(hdc, 0, 0, width, height); ZeroMemory(img, width * height); // Create the font handle and attach it to the DC lf.lfCharSet = DEFAULT_CHARSET; lf.lfClipPrecision = CLIP_DEFAULT_PRECIS; lf.lfEscapement = 0; wcscpy(lf.lfFaceName, fontname); lf.lfHeight = -(fontsize * GetDeviceCaps(GetDC(fgStructure.Window->Window.Handle), LOGPIXELSY) / 72); lf.lfItalic = (style & 1) ? TRUE : FALSE; lf.lfOrientation = 0; lf.lfOutPrecision = OUT_DEFAULT_PRECIS; lf.lfPitchAndFamily = DEFAULT_PITCH | FF_DONTCARE; lf.lfQuality = DEFAULT_QUALITY; lf.lfStrikeOut = FALSE; lf.lfUnderline = (style & 4) ? TRUE : FALSE; lf.lfWidth = 0; lf.lfWeight = (style & 2) ? FW_BOLD : FW_NORMAL; font = CreateFontIndirectW(&lf); SelectObject(hdc, font); // Draw text in white onto the bitmap len = wcslen(string); GetTextExtentPointW(hdc, string, len, &sz); rect.left = max(0, min(x, width)); rect.top = max(0, min(y, height)); rect.right = min(rect.left + sz.cx, width); rect.bottom = min(rect.top + sz.cy, height); DrawTextW(hdc, string, len, &rect, DT_LEFT | DT_BOTTOM); // Traverse the bitmap and add all white pixels into a points buffer points = (GLshort*)malloc(sz.cx * sz.cy * 2 * sizeof(short)); for(yy = rect.top; yy < rect.bottom; yy++) { for(xx = rect.left; xx < rect.right; xx++) { if(img[xx + (height - yy) * width] != 0) { points[nbpoints * 2 + 0] = xx - x; points[nbpoints * 2 + 1] = (short)(rect.top + sz.cy - (yy - rect.top)) - y; nbpoints++; } } } // Delete GDI font object DeleteObject(font); // Prepare the index buffer indices = (GLushort*)malloc(nbpoints * sizeof(GLushort)); for(i = 0; i < nbpoints; i++) indices[i] = i; // Draw the points buffer glMatrixMode(GL_PROJECTION); glPushMatrix(); glLoadIdentity(); glOrthox(0, _INT2FIXED(width), 0, _INT2FIXED(height), 0, _INT2FIXED(1)); glMatrixMode(GL_MODELVIEW); glPushMatrix(); glLoadIdentity(); glDisable(GL_DEPTH_TEST); glTranslatex(_INT2FIXED(x), _INT2FIXED(y), 0); glEnable(GL_ALPHA_TEST); glAlphaFuncx(GL_NOTEQUAL, 0); glDisableClientState(GL_TEXTURE_COORD_ARRAY); glDisableClientState(GL_COLOR_ARRAY); glDisableClientState(GL_NORMAL_ARRAY); glEnableClientState (GL_VERTEX_ARRAY); glVertexPointer(2, GL_SHORT, 0, points); glDrawElements(GL_POINTS, nbpoints, GL_UNSIGNED_SHORT, indices); glDisable(GL_ALPHA_TEST); glEnable(GL_DEPTH_TEST); glPopMatrix(); glMatrixMode(GL_PROJECTION); glPopMatrix(); glMatrixMode(GL_MODELVIEW); free(indices); free(points); }
void OSystem_Android::updateScreen() { //ENTER(); GLTHREADCHECK; if (!JNI::haveSurface()) return; if (!_force_redraw && !_game_texture->dirty() && !_overlay_texture->dirty() && !_mouse_texture->dirty()) return; _force_redraw = false; // clear pointer leftovers in dead areas // also, HTC's GLES drivers are made of fail and don't preserve the buffer // ( http://www.khronos.org/registry/egl/specs/EGLTechNote0001.html ) if ((_show_overlay || _htc_fail) && !_fullscreen) clearScreen(kClear); GLCALL(glPushMatrix()); if (_shake_offset != 0 || (!_focus_rect.isEmpty() && !Common::Rect(_game_texture->width(), _game_texture->height()).contains(_focus_rect))) { // These are the only cases where _game_texture doesn't // cover the entire screen. clearScreen(kClear); // Move everything up by _shake_offset (game) pixels GLCALL(glTranslatex(0, -_shake_offset << 16, 0)); } // TODO this doesn't work on those sucky drivers, do it differently // if (_show_overlay) // GLCALL(glColor4ub(0x9f, 0x9f, 0x9f, 0x9f)); if (_focus_rect.isEmpty()) { _game_texture->drawTextureRect(); } else { GLCALL(glPushMatrix()); GLCALL(glScalex(xdiv(_egl_surface_width, _focus_rect.width()), xdiv(_egl_surface_height, _focus_rect.height()), 1 << 16)); GLCALL(glTranslatex(-_focus_rect.left << 16, -_focus_rect.top << 16, 0)); GLCALL(glScalex(xdiv(_game_texture->width(), _egl_surface_width), xdiv(_game_texture->height(), _egl_surface_height), 1 << 16)); _game_texture->drawTextureRect(); GLCALL(glPopMatrix()); } int cs = _mouse_targetscale; if (_show_overlay) { // TODO see above // GLCALL(glColor4ub(0xff, 0xff, 0xff, 0xff)); // ugly, but the modern theme sets a wacko factor, only god knows why cs = 1; GLCALL(_overlay_texture->drawTextureRect()); } if (_show_mouse && !_mouse_texture->isEmpty()) { GLCALL(glPushMatrix()); const Common::Point &mouse = getEventManager()->getMousePos(); // Scale up ScummVM -> OpenGL (pixel) coordinates if (_show_overlay) { GLCALL(glScalex(xdiv(_egl_surface_width, _overlay_texture->width()), xdiv(_egl_surface_height, _overlay_texture->height()), 1 << 16)); } else { const Common::Rect &r = _game_texture->getDrawRect(); GLCALL(glTranslatex(r.left << 16, r.top << 16, 0)); GLCALL(glScalex(xdiv(r.width(), _game_texture->width()), xdiv(r.height(), _game_texture->height()), 1 << 16)); } GLCALL(glTranslatex((-_mouse_hotspot.x * cs) << 16, (-_mouse_hotspot.y * cs) << 16, 0)); // Note the extra half texel to position the mouse in // the middle of the x,y square: GLCALL(glTranslatex((mouse.x << 16) | 1 << 15, (mouse.y << 16) | 1 << 15, 0)); GLCALL(glScalex(cs << 16, cs << 16, 1 << 16)); _mouse_texture->drawTextureOrigin(); GLCALL(glPopMatrix()); } GLCALL(glPopMatrix()); if (!JNI::swapBuffers()) LOGW("swapBuffers failed: 0x%x", glGetError()); }
void TopographyFileRenderer::Paint(Canvas &canvas, const WindowProjection &projection) { if (file.IsEmpty()) return; fixed map_scale = projection.GetMapScale(); if (!file.IsVisible(map_scale)) return; UpdateVisibleShapes(projection); if (visible_shapes.empty()) return; // TODO code: only draw inside screen! // this will save time with rendering pixmaps especially // we already do an outer visibility test, but may need a test // in screen coords #ifdef ENABLE_OPENGL pen.Set(); brush.Set(); #else shape_renderer.Configure(&pen, &brush); #endif // get drawing info #ifdef ENABLE_OPENGL const unsigned level = file.GetThinningLevel(map_scale); const unsigned min_distance = file.GetMinimumPointDistance(level) / Layout::Scale(1); #ifndef HAVE_GLES float opengl_matrix[16]; glGetFloatv(GL_MODELVIEW_MATRIX, opengl_matrix); #endif glPushMatrix(); fixed angle = projection.GetScreenAngle().Degrees(); fixed scale = projection.GetScale(); const RasterPoint &screen_origin = projection.GetScreenOrigin(); #ifdef HAVE_GLES #ifdef FIXED_MATH GLfixed fixed_angle = angle.as_glfixed(); GLfixed fixed_scale = scale.as_glfixed_scale(); #else GLfixed fixed_angle = angle * (1<<16); GLfixed fixed_scale = scale * (1LL<<32); #endif glTranslatex((int)screen_origin.x << 16, (int)screen_origin.y << 16, 0); glRotatex(fixed_angle, 0, 0, -(1<<16)); glScalex(fixed_scale, fixed_scale, 1<<16); #else glTranslatef(screen_origin.x, screen_origin.y, 0.); glRotatef((GLfloat)angle, 0., 0., -1.); glScalef((GLfloat)scale, (GLfloat)scale, 1.); #endif #else // !ENABLE_OPENGL const GeoClip clip(projection.GetScreenBounds().Scale(fixed(1.1))); AllocatedArray<GeoPoint> geo_points; int iskip = file.GetSkipSteps(map_scale); #endif for (auto it = visible_shapes.begin(), end = visible_shapes.end(); it != end; ++it) { const XShape &shape = **it; if (!projection.GetScreenBounds().Overlaps(shape.get_bounds())) continue; #ifdef ENABLE_OPENGL const ShapePoint *points = shape.get_points(); const ShapePoint translation = shape.shape_translation(projection.GetGeoLocation()); glPushMatrix(); #ifdef HAVE_GLES glTranslatex(translation.x, translation.y, 0); #else glTranslatef(translation.x, translation.y, 0.); #endif #else // !ENABLE_OPENGL const unsigned short *lines = shape.get_lines(); const unsigned short *end_lines = lines + shape.get_number_of_lines(); const GeoPoint *points = shape.get_points(); #endif switch (shape.get_type()) { case MS_SHAPE_NULL: break; case MS_SHAPE_POINT: #ifdef ENABLE_OPENGL #ifdef HAVE_GLES PaintPoint(canvas, projection, shape, NULL); #else PaintPoint(canvas, projection, shape, opengl_matrix); #endif #else // !ENABLE_OPENGL PaintPoint(canvas, projection, lines, end_lines, points); #endif break; case MS_SHAPE_LINE: { #ifdef ENABLE_OPENGL #ifdef HAVE_GLES glVertexPointer(2, GL_FIXED, 0, &points[0].x); #else glVertexPointer(2, GL_INT, 0, &points[0].x); #endif const GLushort *indices, *count; if (level == 0 || (indices = shape.get_indices(level, min_distance, count)) == NULL) { count = shape.get_lines(); const GLushort *end_count = count + shape.get_number_of_lines(); for (int offset = 0; count < end_count; offset += *count++) glDrawArrays(GL_LINE_STRIP, offset, *count); } else { const GLushort *end_count = count + shape.get_number_of_lines(); for (; count < end_count; indices += *count++) glDrawElements(GL_LINE_STRIP, *count, GL_UNSIGNED_SHORT, indices); } #else // !ENABLE_OPENGL for (; lines < end_lines; ++lines) { unsigned msize = *lines; shape_renderer.Begin(msize); const GeoPoint *end = points + msize - 1; for (; points < end; ++points) shape_renderer.AddPointIfDistant(projection.GeoToScreen(*points)); // make sure we always draw the last point shape_renderer.AddPoint(projection.GeoToScreen(*points)); shape_renderer.FinishPolyline(canvas); } #endif } break; case MS_SHAPE_POLYGON: #ifdef ENABLE_OPENGL { const GLushort *index_count; const GLushort *triangles = shape.get_indices(level, min_distance, index_count); #ifdef HAVE_GLES glVertexPointer(2, GL_FIXED, 0, &points[0].x); #else glVertexPointer(2, GL_INT, 0, &points[0].x); #endif glDrawElements(GL_TRIANGLE_STRIP, *index_count, GL_UNSIGNED_SHORT, triangles); } #else // !ENABLE_OPENGL for (; lines < end_lines; ++lines) { unsigned msize = *lines / iskip; /* copy all polygon points into the geo_points array and clip them, to avoid integer overflows (as RasterPoint may store only 16 bit integers on some platforms) */ geo_points.GrowDiscard(msize * 3); for (unsigned i = 0; i < msize; ++i) geo_points[i] = points[i * iskip]; msize = clip.ClipPolygon(geo_points.begin(), geo_points.begin(), msize); if (msize < 3) continue; shape_renderer.Begin(msize); for (unsigned i = 0; i < msize; ++i) { GeoPoint g = geo_points[i]; shape_renderer.AddPointIfDistant(projection.GeoToScreen(g)); } shape_renderer.FinishPolygon(canvas); } #endif break; } #ifdef ENABLE_OPENGL glPopMatrix(); #endif } #ifdef ENABLE_OPENGL glPopMatrix(); #else shape_renderer.Commit(); #endif }
static void gluLookAt(GLfloat eyex, GLfloat eyey, GLfloat eyez, GLfloat centerx, GLfloat centery, GLfloat centerz, GLfloat upx, GLfloat upy, GLfloat upz) { GLfloat m[16]; GLfloat x[3], y[3], z[3]; GLfloat mag; z[0] = eyex - centerx; z[1] = eyey - centery; z[2] = eyez - centerz; mag = (float)sqrt(z[0] * z[0] + z[1] * z[1] + z[2] * z[2]); if (mag) { z[0] /= mag; z[1] /= mag; z[2] /= mag; } y[0] = upx; y[1] = upy; y[2] = upz; x[0] = y[1] * z[2] - y[2] * z[1]; x[1] = -y[0] * z[2] + y[2] * z[0]; x[2] = y[0] * z[1] - y[1] * z[0]; y[0] = z[1] * x[2] - z[2] * x[1]; y[1] = -z[0] * x[2] + z[2] * x[0]; y[2] = z[0] * x[1] - z[1] * x[0]; mag = (float)sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]); if (mag) { x[0] /= mag; x[1] /= mag; x[2] /= mag; } mag = (float)sqrt(y[0] * y[0] + y[1] * y[1] + y[2] * y[2]); if (mag) { y[0] /= mag; y[1] /= mag; y[2] /= mag; } #define M(row,col) m[col*4+row] M(0, 0) = x[0]; M(0, 1) = x[1]; M(0, 2) = x[2]; M(0, 3) = 0.0; M(1, 0) = y[0]; M(1, 1) = y[1]; M(1, 2) = y[2]; M(1, 3) = 0.0; M(2, 0) = z[0]; M(2, 1) = z[1]; M(2, 2) = z[2]; M(2, 3) = 0.0; M(3, 0) = 0.0; M(3, 1) = 0.0; M(3, 2) = 0.0; M(3, 3) = 1.0; #undef M { int a; GLfixed fixedM[16]; for (a = 0; a < 16; ++a) fixedM[a] = (GLfixed)(m[a] * 65536); glMultMatrixx(fixedM); } glTranslatex((GLfixed)(-eyex * 65536), (GLfixed)(-eyey * 65536), (GLfixed)(-eyez * 65536)); }
void glTranslatexLogged(GLfixed x, GLfixed y, GLfixed z) { printf("glTranslatex(%i, %i, %i)\n", x, y, z); glTranslatex(x, y, z); }
void CLT3DEngine::Render() { glClear(GL_COLOR_BUFFER_BIT); glLoadIdentity(); glTranslatex(0, 0, iCameraDistance << 16); glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT); // 清除屏幕和深度缓存 // glPushAttrib(GL_ENABLE_BIT | GL_DEPTH_BUFFER_BIT | GL_CURRENT_BIT // | GL_LIGHTING_BIT | GL_TRANSFORM_BIT | GL_TEXTURE_BIT); glDisable(GL_DEPTH_TEST); glDisable(GL_LIGHTING); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA,GL_ONE); glEnable(GL_TEXTURE_2D); //以上代码使黑色透明 //glLoadIdentity(); // 重置当前的模型观察矩阵 /***********************************新添的代码***********************************************************************************/ for (loop = 0; loop < MAX_PARTICLES; loop++) // 循环所有的粒子 { if (particle[loop].active) // 如果粒子为激活的 { float x = particle[loop].x; // 返回X轴的位置 float y = particle[loop].y; // 返回Y轴的位置 float z = particle[loop].z + zoom; // 返回Z轴的位置 // 设置粒子颜色 glPushMatrix(); glColor4f(particle[loop].r, particle[loop].g, particle[loop].b, particle[loop].life); glTranslatef(x, y, z); glBindTexture(GL_TEXTURE_2D, iOpenGLES.iID); glDrawElements(GL_TRIANGLES, 2 * 3, GL_UNSIGNED_BYTE, triangles); glPopMatrix(); // glBegin(GL_TRIANGLE_STRIP); // 绘制三角形带 // glTexCoord2d(1,1); glVertex3f(x+0.5f,y+0.5f,z); // glTexCoord2d(0,1); glVertex3f(x-0.5f,y+0.5f,z); // glTexCoord2d(1,0); glVertex3f(x+0.5f,y-0.5f,z); // glTexCoord2d(0,0); glVertex3f(x-0.5f,y-0.5f,z); // glEnd(); particle[loop].x += particle[loop].xi / (slowdown * 1000); // 更新X坐标的位置 particle[loop].y += particle[loop].yi / (slowdown * 1000); // 更新Y坐标的位置 particle[loop].z += particle[loop].zi / (slowdown * 1000); // 更新Z坐标的位置 particle[loop].xi += particle[loop].xg; // 更新X轴方向速度大小 particle[loop].yi += particle[loop].yg; // 更新Y轴方向速度大小 particle[loop].zi += particle[loop].zg; // 更新Z轴方向速度大小 particle[loop].life -= particle[loop].fade; // 减少粒子的生命值 if (particle[loop].life < 0.0f) // 如果粒子生命值小于0 { particle[loop].life = 1.0f; // 产生一个新的粒子 particle[loop].fade = float(Math::Random() % 100) / 1000.0f + 0.003f; // 随机生成衰减速率 particle[loop].x = 0.0f; // 新粒子出现在屏幕的中央 particle[loop].y = 0.0f; particle[loop].z = 0.0f; // particle[loop].xi = xspeed + float((Math::Random() % 60) // - 32.0f); // 随机生成粒子速度 // particle[loop].yi = yspeed + float((Math::Random() % 60) // - 30.0f); // particle[loop].zi = float((Math::Random() % 60) - 30.0f); particle[loop].xi=float((Math::Random()%50)-25.0f)*10.0f; // 随机生成X轴方向速度 particle[loop].yi=float((Math::Random()%50)-25.0f)*10.0f; // 随机生成Y轴方向速度 particle[loop].zi=float((Math::Random()%50)-25.0f)*10.0f; // 随机生成Z轴方向速度 particle[loop].xg=float(Math::Random()%50)/1000.0f; // 设置X轴方向加速度为0 particle[loop].yg=float(Math::Random()%50)/1000.0f; // 设置Y轴方向加速度为-0.8 particle[loop].zg=float(Math::Random()%50)/1000.0f; // 设置Z轴方向加速度为0 particle[loop].r = colors[col][0]; // 设置粒子颜色 particle[loop].g = colors[col][1]; particle[loop].b = colors[col][2]; } } } col++; if (col > 11) col = 0; eglSwapBuffers(iEglDisplay, iEglSurface); }
void Canvas::DrawCircle(int x, int y, unsigned radius) { #ifdef USE_GLSL OpenGL::solid_shader->Use(); #endif if (IsPenOverBrush() && pen.GetWidth() > 2) { ScopeVertexPointer vp; GLDonutVertices vertices(x, y, radius - pen.GetWidth() / 2, radius + pen.GetWidth() / 2); if (!brush.IsHollow()) { vertices.BindInnerCircle(vp); brush.Set(); glDrawArrays(GL_TRIANGLE_FAN, 0, vertices.CIRCLE_SIZE); } vertices.Bind(vp); pen.Bind(); glDrawArrays(GL_TRIANGLE_STRIP, 0, vertices.SIZE); pen.Unbind(); } else { GLFallbackArrayBuffer &buffer = radius < 16 ? *OpenGL::small_circle_buffer : *OpenGL::circle_buffer; const unsigned n = radius < 16 ? OpenGL::SMALL_CIRCLE_SIZE : OpenGL::CIRCLE_SIZE; const FloatPoint *const points = (const FloatPoint *)buffer.BeginRead(); const ScopeVertexPointer vp(points); #ifdef USE_GLSL glm::mat4 matrix2 = glm::scale(glm::translate(glm::mat4(), glm::vec3(x, y, 0)), glm::vec3(GLfloat(radius), GLfloat(radius), 1.)); glUniformMatrix4fv(OpenGL::solid_modelview, 1, GL_FALSE, glm::value_ptr(matrix2)); #else glPushMatrix(); #ifdef HAVE_GLES glTranslatex((GLfixed)x << 16, (GLfixed)y << 16, 0); glScalex((GLfixed)radius << 16, (GLfixed)radius << 16, (GLfixed)1 << 16); #else glTranslatef(x, y, 0.); glScalef(radius, radius, 1.); #endif #endif if (!brush.IsHollow()) { brush.Set(); glDrawArrays(GL_TRIANGLE_FAN, 0, n); } if (IsPenOverBrush()) { pen.Bind(); glDrawArrays(GL_LINE_LOOP, 0, n); pen.Unbind(); } #ifdef USE_GLSL glUniformMatrix4fv(OpenGL::solid_modelview, 1, GL_FALSE, glm::value_ptr(glm::mat4())); #else glPopMatrix(); #endif buffer.EndRead(); } }
void CLT3DEngine::DrawTangram() { glMatrixMode(GL_PROJECTION); glLoadIdentity(); GLint width,height; width = iScreenWidth >> 1; height = iScreenHeight >> 1; glOrthof((float)-width, (float) width, (float)-height, (float) height, -1, 1); // set the same size as viewport glMatrixMode(GL_TEXTURE); glLoadIdentity(); glScalef(1.0f / 255.0f, 1.0f / 255.0f, 1.0f); glTranslatef(128.0f, 128.0f, 0.0f); glMatrixMode( GL_MODELVIEW ); glLoadIdentity(); glVertexPointer(2, GL_BYTE, 0, verticesTangram); glTexCoordPointer(2, GL_BYTE, 0, nokTexCoordsTangram); /* Animate and draw box */ glColor4f(1.0f,1.0f,1.0f,1.0f); if (ETrue) { glPushMatrix(); // glTranslatex(0, 0, iCameraDistance << 16); glRotatex(iRotate[0] << 16, 0, 0, 1 << 16); glScalex(25 << 16, 25<<16 ,1 << 16); glTranslatex(iTranslate[0][0] << 16, 0, 0); glTranslatex(0, iTranslate[0][1] << 16, 0); // glTranslatex(0, 2<<16, 0); // glRotatex(iRotate[0] << 16, 0, 0, 1 << 16); // glTranslatex(0, -2<<16, 0); // glRotatex(0,iRotate<<16,0,0); // glRotatex(0,0,iRotate<<16,0); glBindTexture( GL_TEXTURE_2D, iOpenGLES.iID ); glDrawElements(GL_TRIANGLES, 1 * 3, GL_UNSIGNED_BYTE, STTtriangleBig1); glPopMatrix(); } if (ETrue) { glPushMatrix(); // glTranslatex(0, 0, iCameraDistance << 16); glScalex(25 << 16, 25<<16 ,1 << 16); glTranslatex(iTranslate[1][0] << 16, 0, 0); glTranslatex(0, iTranslate[1][1] << 16, 0); glTranslatex(-2<<16, 0, 0); glRotatex(iRotate[1] << 16, 0, 0, 1 << 16); glTranslatex(2<<16, 0, 0); glBindTexture( GL_TEXTURE_2D, iOpenGLES.iID ); glDrawElements(GL_TRIANGLES, 1 * 3, GL_UNSIGNED_BYTE, STTtriangleBig2); glPopMatrix(); } if (ETrue) { glPushMatrix(); // glTranslatex(0, 0, iCameraDistance << 16); glScalex(25 << 16, 25<<16 ,1 << 16); glTranslatex(iTranslate[2][0] << 16, 0, 0); glTranslatex(0, iTranslate[2][1] << 16, 0); glTranslatex(1<<16, 0, 0); glRotatex(iRotate[2] << 16, 0, 0, 1 << 16); glTranslatex(-1<<16, 0, 0); glBindTexture( GL_TEXTURE_2D, iOpenGLES.iID ); glDrawElements(GL_TRIANGLES, 1 * 3, GL_UNSIGNED_BYTE, STTtriangleSmall1); glPopMatrix(); } if (ETrue) { glPushMatrix(); // glTranslatex(0, 0, iCameraDistance << 16); glScalex(25 << 16, 25<<16 ,1 << 16); glTranslatex(iTranslate[3][0] << 16, 0, 0); glTranslatex(0, iTranslate[3][1] << 16, 0); glTranslatex(-2<<16, -3<<16, 0); glRotatex(iRotate[3] << 16, 0, 0, 1 << 16); glTranslatex(2<<16, 3<<16, 0); glBindTexture( GL_TEXTURE_2D, iOpenGLES.iID ); glDrawElements(GL_TRIANGLES, 1 * 3, GL_UNSIGNED_BYTE, STTtriangleSmall2); glPopMatrix(); } if (ETrue) { glPushMatrix(); // glTranslatex(0, 0, iCameraDistance << 16); glScalex(25 << 16, 25<<16 ,1 << 16); glTranslatex(iTranslate[4][0] << 16, 0, 0); glTranslatex(0, iTranslate[4][1] << 16, 0); glTranslatex(3<<16, -3<<16, 0); glRotatex(iRotate[4] << 16, 0, 0, 1 << 16); glTranslatex(-3<<16, 3<<16, 0); glBindTexture( GL_TEXTURE_2D, iOpenGLES.iID ); glDrawElements(GL_TRIANGLES, 1 * 3, GL_UNSIGNED_BYTE, STTtriangleMid); glPopMatrix(); } if (ETrue) { glPushMatrix(); // glTranslatex(0, 0, iCameraDistance << 16); glScalex(25 << 16, 25<<16 ,1 << 16); glTranslatex(iTranslate[5][0] << 16, 0, 0); glTranslatex(0, iTranslate[5][1] << 16, 0); glTranslatex(0, -2<<16, 0); glRotatex(iRotate[5] << 16, 0, 0, 1 << 16); glTranslatex(0, 2<<16, 0); glBindTexture( GL_TEXTURE_2D, iOpenGLES.iID ); glDrawElements(GL_TRIANGLES, 2 * 3, GL_UNSIGNED_BYTE, STSquare); glPopMatrix(); } if (ETrue) { glPushMatrix(); // glTranslatex(0, 0, iCameraDistance << 16); glScalex(25 << 16, 25<<16 ,1 << 16); glTranslatex(iTranslate[6][0] << 16, 0, 0); glTranslatex(0, iTranslate[6][1] << 16, 0); glTranslatex(3<<16, 1<<16, 0); glRotatex(iRotate[6] << 16, 0, 0, 1 << 16); glTranslatex(-3<<16, -1<<16, 0); glBindTexture( GL_TEXTURE_2D, iOpenGLES.iID ); glDrawElements(GL_TRIANGLES, 2 * 3, GL_UNSIGNED_BYTE, STRect); glPopMatrix(); } }
/* Following gluLookAt implementation is adapted from the * Mesa 3D Graphics library. http://www.mesa3d.org */ static void gluLookAt(GLfloat eyex, GLfloat eyey, GLfloat eyez, GLfloat centerx, GLfloat centery, GLfloat centerz, GLfloat upx, GLfloat upy, GLfloat upz) { GLfloat m[16]; GLfloat x[3], y[3], z[3]; GLfloat mag; /* Make rotation matrix */ /* Z vector */ z[0] = eyex - centerx; z[1] = eyey - centery; z[2] = eyez - centerz; mag = (float)sqrt(z[0] * z[0] + z[1] * z[1] + z[2] * z[2]); if (mag) { /* mpichler, 19950515 */ z[0] /= mag; z[1] /= mag; z[2] /= mag; } /* Y vector */ y[0] = upx; y[1] = upy; y[2] = upz; /* X vector = Y cross Z */ x[0] = y[1] * z[2] - y[2] * z[1]; x[1] = -y[0] * z[2] + y[2] * z[0]; x[2] = y[0] * z[1] - y[1] * z[0]; /* Recompute Y = Z cross X */ y[0] = z[1] * x[2] - z[2] * x[1]; y[1] = -z[0] * x[2] + z[2] * x[0]; y[2] = z[0] * x[1] - z[1] * x[0]; /* mpichler, 19950515 */ /* cross product gives area of parallelogram, which is < 1.0 for * non-perpendicular unit-length vectors; so normalize x, y here */ mag = (float)sqrt(x[0] * x[0] + x[1] * x[1] + x[2] * x[2]); if (mag) { x[0] /= mag; x[1] /= mag; x[2] /= mag; } mag = (float)sqrt(y[0] * y[0] + y[1] * y[1] + y[2] * y[2]); if (mag) { y[0] /= mag; y[1] /= mag; y[2] /= mag; } #define M(row,col) m[(col)*4+(row)] M(0, 0) = x[0]; M(0, 1) = x[1]; M(0, 2) = x[2]; M(0, 3) = 0.0; M(1, 0) = y[0]; M(1, 1) = y[1]; M(1, 2) = y[2]; M(1, 3) = 0.0; M(2, 0) = z[0]; M(2, 1) = z[1]; M(2, 2) = z[2]; M(2, 3) = 0.0; M(3, 0) = 0.0; M(3, 1) = 0.0; M(3, 2) = 0.0; M(3, 3) = 1.0; #undef M { int a; GLfixed fixedM[16]; for (a = 0; a < 16; ++a) fixedM[a] = (GLfixed)(m[a] * 65536); glMultMatrixx(fixedM); } /* Translate Eye to Origin */ glTranslatex((GLfixed)(-eyex * 65536), (GLfixed)(-eyey * 65536), (GLfixed)(-eyez * 65536)); }
void CLT3DEngine::DrawParticles() { // Recalculate the view frustrum // glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT); // 清除屏幕和深度缓存 // // glMatrixMode(GL_PROJECTION); // glLoadIdentity(); // GLfloat aspectRatio = (GLfloat) (iScreenWidth) / (GLfloat) (iScreenHeight); // glFrustumf(FRUSTUM_LEFT * aspectRatio, FRUSTUM_RIGHT * aspectRatio, // FRUSTUM_BOTTOM, FRUSTUM_TOP, // FRUSTUM_NEAR, FRUSTUM_FAR ); // // // Enable back face culling. // // glMatrixMode(GL_TEXTURE); // glLoadIdentity(); // glScalef(1.0f / 255.0f, 1.0f / 255.0f, 1.0f); // glTranslatef(128.0f, 128.0f, 0.0f); // // glMatrixMode(GL_MODELVIEW); // glLoadIdentity(); // // glVertexPointer(3, GL_BYTE, 0, vertices); // glTexCoordPointer(2, GL_BYTE, 0, nokTexCoords); // // glEnable(GL_BLEND); // glBlendFunc(GL_SRC_ALPHA,GL_ONE); // glEnable(GL_TEXTURE_2D); // Set array pointers. // glEnable(GL_TEXTURE_2D); //以上代码使黑色透明 glClear(GL_COLOR_BUFFER_BIT); glLoadIdentity(); glTranslatex(0, 0, iCameraDistance << 16); glClear(GL_COLOR_BUFFER_BIT| GL_DEPTH_BUFFER_BIT); // 清除屏幕和深度缓存 // glPushAttrib(GL_ENABLE_BIT | GL_DEPTH_BUFFER_BIT | GL_CURRENT_BIT // | GL_LIGHTING_BIT | GL_TRANSFORM_BIT | GL_TEXTURE_BIT); glDisable(GL_DEPTH_TEST); glDisable(GL_LIGHTING); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA,GL_ONE); glEnable(GL_TEXTURE_2D); //glLoadIdentity(); // 重置当前的模型观察矩阵 // glLoadIdentity(); // glTranslatex(0, 0, iCameraDistance << 16); /***********************************新添的代码***********************************************************************************/ for (loop = 0; loop < MAX_PARTICLES; loop++) // 循环所有的粒子 { if (particle[loop].active) // 如果粒子为激活的 { float x = particle[loop].x; // 返回X轴的位置 float y = particle[loop].y; // 返回Y轴的位置 float z = particle[loop].z + zoom; // 返回Z轴的位置 // 设置粒子颜色 glPushMatrix(); glColor4f(particle[loop].r, particle[loop].g, particle[loop].b, particle[loop].life); glTranslatef(x, y, z); glScalef(10.0f,10.0f,1.0f); glBindTexture(GL_TEXTURE_2D, iTextureParticle.iID); glDrawElements(GL_TRIANGLES, 2 * 3, GL_UNSIGNED_BYTE, triangles); glPopMatrix(); // glBegin(GL_TRIANGLE_STRIP); // 绘制三角形带 // glTexCoord2d(1,1); glVertex3f(x+0.5f,y+0.5f,z); // glTexCoord2d(0,1); glVertex3f(x-0.5f,y+0.5f,z); // glTexCoord2d(1,0); glVertex3f(x+0.5f,y-0.5f,z); // glTexCoord2d(0,0); glVertex3f(x-0.5f,y-0.5f,z); // glEnd(); particle[loop].x += particle[loop].xi / (slowdown * 1000); // 更新X坐标的位置 particle[loop].y += particle[loop].yi / (slowdown * 1000); // 更新Y坐标的位置 particle[loop].z += particle[loop].zi / (slowdown * 1000); // 更新Z坐标的位置 particle[loop].xi += particle[loop].xg; // 更新X轴方向速度大小 particle[loop].yi += particle[loop].yg; // 更新Y轴方向速度大小 particle[loop].zi += particle[loop].zg; // 更新Z轴方向速度大小 particle[loop].life -= particle[loop].fade; // 减少粒子的生命值 if (particle[loop].life < 0.0f) // 如果粒子生命值小于0 { particle[loop].life = 1.0f; // 产生一个新的粒子 particle[loop].fade = float(Math::Random() % 100) / 1000.0f + 0.003f; // 随机生成衰减速率 particle[loop].x = 0.0f; // 新粒子出现在屏幕的中央 particle[loop].y = 0.0f; particle[loop].z = 0.0f; // particle[loop].xi = xspeed + float((Math::Random() % 60) // - 32.0f); // 随机生成粒子速度 // particle[loop].yi = yspeed + float((Math::Random() % 60) // - 30.0f); // particle[loop].zi = float((Math::Random() % 60) - 30.0f); particle[loop].xi=float((Math::Random()%50)-25.0f)*10.0f; // 随机生成X轴方向速度 particle[loop].yi=float((Math::Random()%50)-25.0f)*10.0f; // 随机生成Y轴方向速度 particle[loop].zi=float((Math::Random()%50)-25.0f)*10.0f; // 随机生成Z轴方向速度 particle[loop].xg=float(Math::Random()%50)/1000.0f; // 设置X轴方向加速度为0 particle[loop].yg=float(Math::Random()%50)/1000.0f; // 设置Y轴方向加速度为-0.8 particle[loop].zg=float(Math::Random()%50)/1000.0f; // 设置Z轴方向加速度为0 particle[loop].r = colors[col][0]; // 设置粒子颜色 particle[loop].g = colors[col][1]; particle[loop].b = colors[col][2]; } } } col++; if (col > 11) col = 0; }
void OSystem_Android::updateScreen() { //ENTER(); GLTHREADCHECK; if (!JNI::haveSurface()) return; if (_game_pbuf) { int pitch = _game_texture->width() * _game_texture->getPixelFormat().bytesPerPixel; _game_texture->updateBuffer(0, 0, _game_texture->width(), _game_texture->height(), _game_pbuf.getRawBuffer(), pitch); } if (!_force_redraw && !_game_texture->dirty() && !_overlay_texture->dirty() && !_mouse_texture->dirty()) return; _force_redraw = false; if (_frame_buffer) { _frame_buffer->detach(); glViewport(0,0, _egl_surface_width, _egl_surface_height); } // clear pointer leftovers in dead areas clearScreen(kClear); // TODO this doesnt work on those sucky drivers, do it differently // if (_show_overlay) // GLCALL(glColor4ub(0x9f, 0x9f, 0x9f, 0x9f)); if (true || _focus_rect.isEmpty()) { _game_texture->drawTextureRect(); drawVirtControls(); } else { // TODO what is this and do we have engines using it? #if 0 GLCALL(glPushMatrix()); GLCALL(glScalex(xdiv(_egl_surface_width, _focus_rect.width()), xdiv(_egl_surface_height, _focus_rect.height()), 1 << 16)); GLCALL(glTranslatex(-_focus_rect.left << 16, -_focus_rect.top << 16, 0)); GLCALL(glScalex(xdiv(_game_texture->width(), _egl_surface_width), xdiv(_game_texture->height(), _egl_surface_height), 1 << 16)); _game_texture->drawTextureRect(); GLCALL(glPopMatrix()); #endif } int cs = _mouse_targetscale; if (_show_overlay) { // TODO see above // GLCALL(glColor4ub(0xff, 0xff, 0xff, 0xff)); // ugly, but the modern theme sets a wacko factor, only god knows why cs = 1; GLCALL(_overlay_texture->drawTextureRect()); } if (_show_mouse && !_mouse_texture->isEmpty()) { const Common::Point &mouse = getEventManager()->getMousePos(); if (_show_overlay) { _mouse_texture->drawTexture(mouse.x * cs, mouse.y * cs, _mouse_texture->width(), _mouse_texture->height()); } // TODO: Port the non-overlay code as well? #if 0 if (_show_overlay) { } else { const Common::Rect &r = _game_texture->getDrawRect(); GLCALL(glTranslatex(r.left << 16, r.top << 16, 0)); GLCALL(glScalex(xdiv(r.width(), _game_texture->width()), xdiv(r.height(), _game_texture->height()), 1 << 16)); } GLCALL(glTranslatex((-_mouse_hotspot.x * cs) << 16, (-_mouse_hotspot.y * cs) << 16, 0)); #endif } if (!JNI::swapBuffers()) LOGW("swapBuffers failed: 0x%x", glGetError()); if (_frame_buffer) _frame_buffer->attach(); }
void Canvas::DrawCircle(PixelScalar x, PixelScalar y, UPixelScalar radius) { if (pen_over_brush() && pen.GetWidth() > 2) { GLDonutVertices vertices(x, y, radius - pen.GetWidth() / 2, radius + pen.GetWidth() / 2); if (!brush.IsHollow()) { vertices.bind_inner_circle(); brush.Set(); glDrawArrays(GL_TRIANGLE_FAN, 0, vertices.CIRCLE_SIZE); } vertices.bind(); pen.Set(); glDrawArrays(GL_TRIANGLE_STRIP, 0, vertices.SIZE); } else if (OpenGL::vertex_buffer_object && radius < 16) { /* draw a "small" circle with VBO */ OpenGL::small_circle_buffer->Bind(); glVertexPointer(2, GL_SHORT, 0, NULL); glPushMatrix(); #ifdef HAVE_GLES glTranslatex((GLfixed)x << 16, (GLfixed)y << 16, 0); glScalex((GLfixed)radius << 8, (GLfixed)radius << 8, (GLfixed)1 << 16); #else glTranslatef(x, y, 0.); glScalef(radius / 256., radius / 256., 1.); #endif if (!brush.IsHollow()) { brush.Set(); glDrawArrays(GL_TRIANGLE_FAN, 0, OpenGL::SMALL_CIRCLE_SIZE); } if (pen_over_brush()) { pen.Bind(); glDrawArrays(GL_LINE_LOOP, 0, OpenGL::SMALL_CIRCLE_SIZE); pen.Unbind(); } glPopMatrix(); OpenGL::small_circle_buffer->Unbind(); } else if (OpenGL::vertex_buffer_object) { /* draw a "big" circle with VBO */ OpenGL::circle_buffer->Bind(); glVertexPointer(2, GL_SHORT, 0, NULL); glPushMatrix(); #ifdef HAVE_GLES glTranslatex((GLfixed)x << 16, (GLfixed)y << 16, 0); glScalex((GLfixed)radius << 6, (GLfixed)radius << 6, (GLfixed)1 << 16); #else glTranslatef(x, y, 0.); glScalef(radius / 1024., radius / 1024., 1.); #endif if (!brush.IsHollow()) { brush.Set(); glDrawArrays(GL_TRIANGLE_FAN, 0, OpenGL::CIRCLE_SIZE); } if (pen_over_brush()) { pen.Bind(); glDrawArrays(GL_LINE_LOOP, 0, OpenGL::CIRCLE_SIZE); pen.Unbind(); } glPopMatrix(); OpenGL::circle_buffer->Unbind(); } else { GLCircleVertices vertices(x, y, radius); vertices.bind(); if (!brush.IsHollow()) { brush.Set(); glDrawArrays(GL_TRIANGLE_FAN, 0, vertices.SIZE); } if (pen_over_brush()) { pen.Bind(); glDrawArrays(GL_LINE_LOOP, 0, vertices.SIZE); pen.Unbind(); } } }
static void ogl_translate(int x, int y) { //glTranslatef((float)x, (float)y, 0.0f); glTranslatex(x<<16, y<<16, 0); }
/*! * \brief Render the OpenGL ES scene. * \param time Current time in milliseconds * \note Renders the OpenGL ES scene *//*-------------------------------------------------------------------*/ void renderGLESScene(unsigned int time) { int width = 0; int height = 0; #if defined(TEST_LOCKSURFACE) KDuint16 *fb = KD_NULL; int y = 0; EGLint pitch = 0; EGLint origin = 0; EGLint r, g, b; #else /* Time needed for the rotation */ const KDfloat32 effectTime = kdFmodf(time / 4000.0f, 360.0f); #endif /* Query the current window surface size from EGL */ eglQuerySurface(GLOBALS->eglDisplay, GLOBALS->eglWindowSurface, EGL_WIDTH, (EGLint *)&width); eglQuerySurface(GLOBALS->eglDisplay, GLOBALS->eglWindowSurface, EGL_HEIGHT, (EGLint *)&height); #if !defined(TEST_LOCKSURFACE) /* Update the GLES state */ updateOpenGLESState (width, height); glClear (GL_COLOR_BUFFER_BIT); /* Rotate the world matrix and translate it on the z-axis */ glMatrixMode (GL_MODELVIEW); glLoadIdentity (); glTranslatex (F2F(0.f), F2F(0.f), F2F(-30.f)); glRotatex (F2F((float)(effectTime*29.77f)), F2F(1.0f), F2F(2.0f), F2F(0.0f)); glRotatex (F2F((float)(effectTime*22.311f)), F2F(-0.1f), F2F(0.0f), -F2F(5.0f)); glBindTexture(GL_TEXTURE_2D, GLOBALS->tex); /* Set the pointer to the arrays containing the cube vertices, normals and texture coordinates */ glVertexPointer (3, GL_BYTE, 0, s_cubeVertices); glNormalPointer (GL_BYTE, 0, s_cubeNormals); glTexCoordPointer (2, GL_BYTE, 0, s_cubeTexCoords); /* Draw the cube one face at a time in the same order thay have been defined in the s_cubeVertices array */ glDrawArrays (GL_TRIANGLE_STRIP, 0, 4); glDrawArrays (GL_TRIANGLE_STRIP, 4, 4); glDrawArrays (GL_TRIANGLE_STRIP, 8, 4); glDrawArrays (GL_TRIANGLE_STRIP, 12, 4); glDrawArrays (GL_TRIANGLE_STRIP, 16, 4); glDrawArrays (GL_TRIANGLE_STRIP, 20, 4); #else /* Lock the surface and query for the properties */ eglLockSurfaceKHR(GLOBALS->eglDisplay, GLOBALS->eglWindowSurface, KD_NULL); eglQuerySurface(GLOBALS->eglDisplay, GLOBALS->eglWindowSurface, EGL_BITMAP_POINTER_KHR, (EGLint *)&fb); eglQuerySurface(GLOBALS->eglDisplay, GLOBALS->eglWindowSurface, EGL_BITMAP_PITCH_KHR, &pitch); eglQuerySurface(GLOBALS->eglDisplay, GLOBALS->eglWindowSurface, EGL_BITMAP_ORIGIN_KHR, &origin); eglQuerySurface(GLOBALS->eglDisplay, GLOBALS->eglWindowSurface, EGL_BITMAP_PIXEL_RED_OFFSET_KHR, &r); eglQuerySurface(GLOBALS->eglDisplay, GLOBALS->eglWindowSurface, EGL_BITMAP_PIXEL_GREEN_OFFSET_KHR, &g); eglQuerySurface(GLOBALS->eglDisplay, GLOBALS->eglWindowSurface, EGL_BITMAP_PIXEL_BLUE_OFFSET_KHR, &b); /* Fill the surface with random noise */ for(y = 0; y < height; y++) { kdCryptoRandom((KDuint8 *)fb, width * 2); fb += pitch / 2; } eglUnlockSurfaceKHR(GLOBALS->eglDisplay, GLOBALS->eglWindowSurface); #endif /* Display the result on the screen */ eglSwapBuffers (GLOBALS->eglDisplay, GLOBALS->eglWindowSurface); }