[Libreoffice-commits] .: slideshow/source
Norbert Thiebaud
nthiebaud at kemper.freedesktop.org
Sun Dec 5 10:57:12 PST 2010
slideshow/source/engine/OGLTrans/mac/OGLTrans_Shaders.h | 94
slideshow/source/engine/OGLTrans/mac/OGLTrans_Shaders.m | 236 +
slideshow/source/engine/OGLTrans/mac/OGLTrans_Shaders_MACOSX.h | 94
slideshow/source/engine/OGLTrans/mac/OGLTrans_Shaders_MACOSX.m | 236 -
slideshow/source/engine/OGLTrans/mac/OGLTrans_TransitionImpl.mm | 1329 ++++++++
slideshow/source/engine/OGLTrans/mac/OGLTrans_TransitionImpl_MACOSX.mm | 1329 --------
slideshow/source/engine/OGLTrans/mac/OGLTrans_TransitionerImpl.mm | 1135 +++++++
slideshow/source/engine/OGLTrans/mac/OGLTrans_TransitionerImpl_MACOSX.mm | 1135 -------
slideshow/source/engine/OGLTrans/mac/makefile.mk | 6
slideshow/source/engine/OGLTrans/unx/OGLTrans_Shaders.cxx | 143
slideshow/source/engine/OGLTrans/unx/OGLTrans_Shaders_LINUX.cxx | 143
slideshow/source/engine/OGLTrans/unx/OGLTrans_TransitionerImpl.cxx | 1487 ++++++++++
slideshow/source/engine/OGLTrans/unx/OGLTrans_TransitionerImpl_LINUX.cxx | 1487 ----------
slideshow/source/engine/OGLTrans/unx/makefile.mk | 4
slideshow/source/engine/OGLTrans/win/OGLTrans_Shaders.cxx | 143
slideshow/source/engine/OGLTrans/win/OGLTrans_Shaders_WNT.cxx | 143
slideshow/source/engine/OGLTrans/win/OGLTrans_TransitionerImpl.cxx | 1455 +++++++++
slideshow/source/engine/OGLTrans/win/OGLTrans_TransitionerImpl_WNT.cxx | 1455 ---------
slideshow/source/engine/OGLTrans/win/makefile.mk | 6
19 files changed, 6030 insertions(+), 6030 deletions(-)
New commits:
commit 02d1ce49d08f947e4e9efb16e59fa5085d2755e7
Author: Robert Nagy <robert at openbsd.org>
Date: Sun Dec 5 16:21:14 2010 +0100
do not include OS in the filenames
In unx the code is not LINUX only, it's mesa.
On other platforms there is no point in using the OS name in the
filenames either.
This unbreaks unx builds on non-linux.
diff --git a/slideshow/source/engine/OGLTrans/mac/OGLTrans_Shaders.h b/slideshow/source/engine/OGLTrans/mac/OGLTrans_Shaders.h
new file mode 100644
index 0000000..7550048
--- /dev/null
+++ b/slideshow/source/engine/OGLTrans/mac/OGLTrans_Shaders.h
@@ -0,0 +1,94 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2008 by Sun Microsystems, Inc.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * $RCSfile: $
+ * $Revision: $
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+#ifndef INCLUDED_OGLTRANS_SHADERS_HXX_
+#define INCLUDED_OGLTRANS_SHADERS_HXX_
+
+/* FIXME : Really needed ? */
+#define GL_GLEXT_PROTOTYPES 1
+
+/* Required Includes */
+#import <Cocoa/Cocoa.h>
+#import <OpenGL/gl.h>
+#import <OpenGL/glext.h>
+#import <OpenGL/glu.h>
+#import <OpenGL/OpenGL.h>
+#import <GLUT/glut.h>
+
+/* Parameter */
+typedef struct _Parameter {
+ float current [4];
+ float min [4];
+ float max [4];
+ float delta [4];
+
+} Parameter;
+
+/* Macros */
+#define PARAMETER_CURRENT(p) (p.current)
+#define PARAMETER_ANIMATE(p) ({ int i; for (i = 0; i < 4; i ++) { \
+ p.current[i] += p.delta[i]; \
+ if ((p.current[i] < p.min[i]) || (p.current[i] > p.max[i])) \
+ p.delta[i] = -p.delta[i]; } } )
+
+/* OGLShaders base class */
+ at interface OGLShaders : NSObject
+{
+ BOOL initialised;
+ GLhandleARB vertex_shader;
+ GLhandleARB fragment_shader;
+ GLhandleARB program_object;
+ GLUquadric *quadric;
+ BOOL gpuProcessingInit;
+ BOOL gpuProcessing;
+}
+- (id) init;
+- (void) initLazy;
+- (void) dealloc;
+- (NSString *) name;
+- (NSString *) descriptionFilename;
+- (unsigned int) loadVertexShader: (NSString *) vertexString fragmentShader: (NSString *) fragmentString;
+
+ /* if!initialized -> initLazy */
+- (void) renderFrame;
+
+/* Check whether software rasterization or software vertex processing will be used */
+- (BOOL) reflect;
+
+ at end
+
+
+// Utility Functions
+
+int NextHighestPowerOf2(int n);
+void CopyFramebufferToTexture(GLuint texture);
+NSBitmapImageRep *LoadImage(NSString *path, int shouldFlipVertical);
+
+#endif
diff --git a/slideshow/source/engine/OGLTrans/mac/OGLTrans_Shaders.m b/slideshow/source/engine/OGLTrans/mac/OGLTrans_Shaders.m
new file mode 100644
index 0000000..51b21dd
--- /dev/null
+++ b/slideshow/source/engine/OGLTrans/mac/OGLTrans_Shaders.m
@@ -0,0 +1,236 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2008 by Sun Microsystems, Inc.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * $RCSfile: $
+ * $Revision: $
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+//#include <osl/diagnose.hxx>
+
+#import "OGLTrans_Shaders.h"
+
+
+ at implementation OGLShaders
+
+- (id) init
+{
+ [super init];
+ gpuProcessingInit = NO;
+ return self;
+}
+
+- (void) initLazy
+{
+ /* Subclass should put initialisation code that can be performaned
+ lazily (on first frame render) here */
+ initialised = TRUE;
+
+ /* Create a GLU quadric, used for rendering certain geometry */
+ quadric = gluNewQuadric();
+ gluQuadricDrawStyle(quadric, GLU_FILL);
+ gluQuadricNormals(quadric, GL_SMOOTH);
+ gluQuadricTexture(quadric, GL_TRUE);
+
+}
+
+- (void) dealloc
+{
+ /* Free the GLU quadric */
+ if (quadric)
+ gluDeleteQuadric(quadric);
+
+ [super dealloc];
+}
+
+- (NSString *) name
+{
+ return @"Unnamed OGLShaders";
+}
+
+- (NSString *) descriptionFilename
+{
+ return NULL;
+}
+
+- (unsigned int) loadVertexShader: (NSString *) vertexString fragmentShader: (NSString *) fragmentString
+{
+ const GLcharARB *vertex_string;
+ const GLcharARB *fragment_string;
+ GLint vertex_compiled;
+ GLint fragment_compiled;
+ GLint linked;
+
+ /* Delete any existing program object */
+ if (program_object) {
+ glDeleteObjectARB(program_object);
+ program_object = NULL;
+ }
+
+ /* Load and compile both shaders */
+ if (vertexString) {
+ vertex_shader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
+ vertex_string = (GLcharARB *) [vertexString cString];
+ glShaderSourceARB(vertex_shader, 1, &vertex_string, NULL);
+ glCompileShaderARB(vertex_shader);
+ glGetObjectParameterivARB(vertex_shader, GL_OBJECT_COMPILE_STATUS_ARB, &vertex_compiled);
+ /* TODO - Get info log */
+ } else {
+ vertex_shader = NULL;
+ vertex_compiled = 1;
+ }
+
+ if (fragmentString) {
+ fragment_shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
+ fragment_string = [fragmentString cString];
+ glShaderSourceARB(fragment_shader, 1, &fragment_string, NULL);
+ glCompileShaderARB(fragment_shader);
+ glGetObjectParameterivARB(fragment_shader, GL_OBJECT_COMPILE_STATUS_ARB, &fragment_compiled);
+ /* TODO - Get info log */
+ } else {
+ fragment_shader = NULL;
+ fragment_compiled = 1;
+ }
+
+ /* Ensure both shaders compiled */
+ if (!vertex_compiled || !fragment_compiled) {
+ if (vertex_shader) {
+ glDeleteObjectARB(vertex_shader);
+ vertex_shader = NULL;
+ }
+ if (fragment_shader) {
+ glDeleteObjectARB(fragment_shader);
+ fragment_shader = NULL;
+ }
+ return 1;
+ }
+
+ /* Create a program object and link both shaders */
+ program_object = glCreateProgramObjectARB();
+ if (vertex_shader != NULL)
+ {
+ glAttachObjectARB(program_object, vertex_shader);
+ glDeleteObjectARB(vertex_shader); /* Release */
+ }
+ if (fragment_shader != NULL)
+ {
+ glAttachObjectARB(program_object, fragment_shader);
+ glDeleteObjectARB(fragment_shader); /* Release */
+ }
+ glLinkProgramARB(program_object);
+ glGetObjectParameterivARB(program_object, GL_OBJECT_LINK_STATUS_ARB, &linked);
+ /* TODO - Get info log */
+
+ if (!linked) {
+ glDeleteObjectARB(program_object);
+ program_object = NULL;
+ return 1;
+ }
+
+ return 0;
+}
+
+- (void) renderFrame
+{
+ if (!initialised)
+ [self initLazy];
+}
+
+- (BOOL) reflect
+{
+ if(!gpuProcessingInit)
+ {
+ /* Check if this will fall back to software rasterization or
+ software vertex processing and don't reflect if it is. */
+
+ GLint fragmentGPUProcessing, vertexGPUProcessing;
+ gpuProcessingInit = YES;
+
+ glPushAttrib(GL_VIEWPORT_BIT);
+ glViewport(0,0,0,0);
+ glPushMatrix();
+ [self renderFrame];
+ glPopMatrix();
+ CGLGetParameter(CGLGetCurrentContext(), kCGLCPGPUFragmentProcessing, &fragmentGPUProcessing);
+ CGLGetParameter(CGLGetCurrentContext(), kCGLCPGPUVertexProcessing, &vertexGPUProcessing);
+ gpuProcessing = (fragmentGPUProcessing && vertexGPUProcessing) ? YES : NO;
+ glPopAttrib();
+ }
+
+ return gpuProcessing;
+}
+
+ at end
+
+
+// Utility Functions
+
+int NextHighestPowerOf2(int n)
+{
+ n--;
+ n |= n >> 1;
+ n |= n >> 2;
+ n |= n >> 4;
+ n |= n >> 8;
+ n |= n >> 16;
+ n++;
+ return n;
+}
+
+void CopyFramebufferToTexture(GLuint texture)
+{
+ GLint viewport[4];
+ glGetIntegerv(GL_VIEWPORT, viewport);
+ glBindTexture(GL_TEXTURE_2D, texture);
+ glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, viewport[0], viewport[1], NextHighestPowerOf2(viewport[2]), NextHighestPowerOf2(viewport[3]), 0);
+}
+
+NSBitmapImageRep *LoadImage(NSString *path, int shouldFlipVertical)
+{
+ NSBitmapImageRep *bitmapimagerep;
+ NSImage *image;
+ image = [[[NSImage alloc] initWithContentsOfFile: path] autorelease];
+ bitmapimagerep = [[NSBitmapImageRep alloc] initWithData:[image TIFFRepresentation]];
+
+ if (shouldFlipVertical)
+ {
+ int bytesPerRow, lowRow, highRow;
+ unsigned char *pixelData, *swapRow;
+
+ bytesPerRow = [bitmapimagerep bytesPerRow];
+ pixelData = [bitmapimagerep bitmapData];
+
+ swapRow = (unsigned char *)malloc(bytesPerRow);
+ for (lowRow = 0, highRow = [bitmapimagerep pixelsHigh]-1; lowRow < highRow; lowRow++, highRow--)
+ {
+ memcpy(swapRow, &pixelData[lowRow*bytesPerRow], bytesPerRow);
+ memcpy(&pixelData[lowRow*bytesPerRow], &pixelData[highRow*bytesPerRow], bytesPerRow);
+ memcpy(&pixelData[highRow*bytesPerRow], swapRow, bytesPerRow);
+ }
+ free(swapRow);
+ }
+
+ return bitmapimagerep;
+}
diff --git a/slideshow/source/engine/OGLTrans/mac/OGLTrans_Shaders_MACOSX.h b/slideshow/source/engine/OGLTrans/mac/OGLTrans_Shaders_MACOSX.h
deleted file mode 100644
index 7550048..0000000
--- a/slideshow/source/engine/OGLTrans/mac/OGLTrans_Shaders_MACOSX.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/*************************************************************************
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * Copyright 2008 by Sun Microsystems, Inc.
- *
- * OpenOffice.org - a multi-platform office productivity suite
- *
- * $RCSfile: $
- * $Revision: $
- *
- * This file is part of OpenOffice.org.
- *
- * OpenOffice.org is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 3
- * only, as published by the Free Software Foundation.
- *
- * OpenOffice.org is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License version 3 for more details
- * (a copy is included in the LICENSE file that accompanied this code).
- *
- * You should have received a copy of the GNU Lesser General Public License
- * version 3 along with OpenOffice.org. If not, see
- * <http://www.openoffice.org/license.html>
- * for a copy of the LGPLv3 License.
- *
- ************************************************************************/
-
-#ifndef INCLUDED_OGLTRANS_SHADERS_HXX_
-#define INCLUDED_OGLTRANS_SHADERS_HXX_
-
-/* FIXME : Really needed ? */
-#define GL_GLEXT_PROTOTYPES 1
-
-/* Required Includes */
-#import <Cocoa/Cocoa.h>
-#import <OpenGL/gl.h>
-#import <OpenGL/glext.h>
-#import <OpenGL/glu.h>
-#import <OpenGL/OpenGL.h>
-#import <GLUT/glut.h>
-
-/* Parameter */
-typedef struct _Parameter {
- float current [4];
- float min [4];
- float max [4];
- float delta [4];
-
-} Parameter;
-
-/* Macros */
-#define PARAMETER_CURRENT(p) (p.current)
-#define PARAMETER_ANIMATE(p) ({ int i; for (i = 0; i < 4; i ++) { \
- p.current[i] += p.delta[i]; \
- if ((p.current[i] < p.min[i]) || (p.current[i] > p.max[i])) \
- p.delta[i] = -p.delta[i]; } } )
-
-/* OGLShaders base class */
- at interface OGLShaders : NSObject
-{
- BOOL initialised;
- GLhandleARB vertex_shader;
- GLhandleARB fragment_shader;
- GLhandleARB program_object;
- GLUquadric *quadric;
- BOOL gpuProcessingInit;
- BOOL gpuProcessing;
-}
-- (id) init;
-- (void) initLazy;
-- (void) dealloc;
-- (NSString *) name;
-- (NSString *) descriptionFilename;
-- (unsigned int) loadVertexShader: (NSString *) vertexString fragmentShader: (NSString *) fragmentString;
-
- /* if!initialized -> initLazy */
-- (void) renderFrame;
-
-/* Check whether software rasterization or software vertex processing will be used */
-- (BOOL) reflect;
-
- at end
-
-
-// Utility Functions
-
-int NextHighestPowerOf2(int n);
-void CopyFramebufferToTexture(GLuint texture);
-NSBitmapImageRep *LoadImage(NSString *path, int shouldFlipVertical);
-
-#endif
diff --git a/slideshow/source/engine/OGLTrans/mac/OGLTrans_Shaders_MACOSX.m b/slideshow/source/engine/OGLTrans/mac/OGLTrans_Shaders_MACOSX.m
deleted file mode 100644
index 73c76ce..0000000
--- a/slideshow/source/engine/OGLTrans/mac/OGLTrans_Shaders_MACOSX.m
+++ /dev/null
@@ -1,236 +0,0 @@
-/*************************************************************************
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * Copyright 2008 by Sun Microsystems, Inc.
- *
- * OpenOffice.org - a multi-platform office productivity suite
- *
- * $RCSfile: $
- * $Revision: $
- *
- * This file is part of OpenOffice.org.
- *
- * OpenOffice.org is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 3
- * only, as published by the Free Software Foundation.
- *
- * OpenOffice.org is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License version 3 for more details
- * (a copy is included in the LICENSE file that accompanied this code).
- *
- * You should have received a copy of the GNU Lesser General Public License
- * version 3 along with OpenOffice.org. If not, see
- * <http://www.openoffice.org/license.html>
- * for a copy of the LGPLv3 License.
- *
- ************************************************************************/
-
-//#include <osl/diagnose.hxx>
-
-#import "OGLTrans_Shaders_MACOSX.h"
-
-
- at implementation OGLShaders
-
-- (id) init
-{
- [super init];
- gpuProcessingInit = NO;
- return self;
-}
-
-- (void) initLazy
-{
- /* Subclass should put initialisation code that can be performaned
- lazily (on first frame render) here */
- initialised = TRUE;
-
- /* Create a GLU quadric, used for rendering certain geometry */
- quadric = gluNewQuadric();
- gluQuadricDrawStyle(quadric, GLU_FILL);
- gluQuadricNormals(quadric, GL_SMOOTH);
- gluQuadricTexture(quadric, GL_TRUE);
-
-}
-
-- (void) dealloc
-{
- /* Free the GLU quadric */
- if (quadric)
- gluDeleteQuadric(quadric);
-
- [super dealloc];
-}
-
-- (NSString *) name
-{
- return @"Unnamed OGLShaders";
-}
-
-- (NSString *) descriptionFilename
-{
- return NULL;
-}
-
-- (unsigned int) loadVertexShader: (NSString *) vertexString fragmentShader: (NSString *) fragmentString
-{
- const GLcharARB *vertex_string;
- const GLcharARB *fragment_string;
- GLint vertex_compiled;
- GLint fragment_compiled;
- GLint linked;
-
- /* Delete any existing program object */
- if (program_object) {
- glDeleteObjectARB(program_object);
- program_object = NULL;
- }
-
- /* Load and compile both shaders */
- if (vertexString) {
- vertex_shader = glCreateShaderObjectARB(GL_VERTEX_SHADER_ARB);
- vertex_string = (GLcharARB *) [vertexString cString];
- glShaderSourceARB(vertex_shader, 1, &vertex_string, NULL);
- glCompileShaderARB(vertex_shader);
- glGetObjectParameterivARB(vertex_shader, GL_OBJECT_COMPILE_STATUS_ARB, &vertex_compiled);
- /* TODO - Get info log */
- } else {
- vertex_shader = NULL;
- vertex_compiled = 1;
- }
-
- if (fragmentString) {
- fragment_shader = glCreateShaderObjectARB(GL_FRAGMENT_SHADER_ARB);
- fragment_string = [fragmentString cString];
- glShaderSourceARB(fragment_shader, 1, &fragment_string, NULL);
- glCompileShaderARB(fragment_shader);
- glGetObjectParameterivARB(fragment_shader, GL_OBJECT_COMPILE_STATUS_ARB, &fragment_compiled);
- /* TODO - Get info log */
- } else {
- fragment_shader = NULL;
- fragment_compiled = 1;
- }
-
- /* Ensure both shaders compiled */
- if (!vertex_compiled || !fragment_compiled) {
- if (vertex_shader) {
- glDeleteObjectARB(vertex_shader);
- vertex_shader = NULL;
- }
- if (fragment_shader) {
- glDeleteObjectARB(fragment_shader);
- fragment_shader = NULL;
- }
- return 1;
- }
-
- /* Create a program object and link both shaders */
- program_object = glCreateProgramObjectARB();
- if (vertex_shader != NULL)
- {
- glAttachObjectARB(program_object, vertex_shader);
- glDeleteObjectARB(vertex_shader); /* Release */
- }
- if (fragment_shader != NULL)
- {
- glAttachObjectARB(program_object, fragment_shader);
- glDeleteObjectARB(fragment_shader); /* Release */
- }
- glLinkProgramARB(program_object);
- glGetObjectParameterivARB(program_object, GL_OBJECT_LINK_STATUS_ARB, &linked);
- /* TODO - Get info log */
-
- if (!linked) {
- glDeleteObjectARB(program_object);
- program_object = NULL;
- return 1;
- }
-
- return 0;
-}
-
-- (void) renderFrame
-{
- if (!initialised)
- [self initLazy];
-}
-
-- (BOOL) reflect
-{
- if(!gpuProcessingInit)
- {
- /* Check if this will fall back to software rasterization or
- software vertex processing and don't reflect if it is. */
-
- GLint fragmentGPUProcessing, vertexGPUProcessing;
- gpuProcessingInit = YES;
-
- glPushAttrib(GL_VIEWPORT_BIT);
- glViewport(0,0,0,0);
- glPushMatrix();
- [self renderFrame];
- glPopMatrix();
- CGLGetParameter(CGLGetCurrentContext(), kCGLCPGPUFragmentProcessing, &fragmentGPUProcessing);
- CGLGetParameter(CGLGetCurrentContext(), kCGLCPGPUVertexProcessing, &vertexGPUProcessing);
- gpuProcessing = (fragmentGPUProcessing && vertexGPUProcessing) ? YES : NO;
- glPopAttrib();
- }
-
- return gpuProcessing;
-}
-
- at end
-
-
-// Utility Functions
-
-int NextHighestPowerOf2(int n)
-{
- n--;
- n |= n >> 1;
- n |= n >> 2;
- n |= n >> 4;
- n |= n >> 8;
- n |= n >> 16;
- n++;
- return n;
-}
-
-void CopyFramebufferToTexture(GLuint texture)
-{
- GLint viewport[4];
- glGetIntegerv(GL_VIEWPORT, viewport);
- glBindTexture(GL_TEXTURE_2D, texture);
- glCopyTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, viewport[0], viewport[1], NextHighestPowerOf2(viewport[2]), NextHighestPowerOf2(viewport[3]), 0);
-}
-
-NSBitmapImageRep *LoadImage(NSString *path, int shouldFlipVertical)
-{
- NSBitmapImageRep *bitmapimagerep;
- NSImage *image;
- image = [[[NSImage alloc] initWithContentsOfFile: path] autorelease];
- bitmapimagerep = [[NSBitmapImageRep alloc] initWithData:[image TIFFRepresentation]];
-
- if (shouldFlipVertical)
- {
- int bytesPerRow, lowRow, highRow;
- unsigned char *pixelData, *swapRow;
-
- bytesPerRow = [bitmapimagerep bytesPerRow];
- pixelData = [bitmapimagerep bitmapData];
-
- swapRow = (unsigned char *)malloc(bytesPerRow);
- for (lowRow = 0, highRow = [bitmapimagerep pixelsHigh]-1; lowRow < highRow; lowRow++, highRow--)
- {
- memcpy(swapRow, &pixelData[lowRow*bytesPerRow], bytesPerRow);
- memcpy(&pixelData[lowRow*bytesPerRow], &pixelData[highRow*bytesPerRow], bytesPerRow);
- memcpy(&pixelData[highRow*bytesPerRow], swapRow, bytesPerRow);
- }
- free(swapRow);
- }
-
- return bitmapimagerep;
-}
diff --git a/slideshow/source/engine/OGLTrans/mac/OGLTrans_TransitionImpl.mm b/slideshow/source/engine/OGLTrans/mac/OGLTrans_TransitionImpl.mm
new file mode 100644
index 0000000..d2c7a24
--- /dev/null
+++ b/slideshow/source/engine/OGLTrans/mac/OGLTrans_TransitionImpl.mm
@@ -0,0 +1,1329 @@
+/*************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2008 by Sun Microsystems, Inc.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * $RCSfile: OGLTrans_TransitionImpl.cxx,v $
+ * $Revision: 1.5.12.1 $
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org. If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ ************************************************************************/
+
+#include "OGLTrans_TransitionImpl.hxx"
+#include "OGLTrans_Shaders.h"
+#ifdef QUARTZ
+#include <OpenGL/gl.h>
+#else
+#include <GL/gl.h>
+#endif
+#include <math.h>
+
+void OGLTransitionImpl::clear()
+{
+ for(unsigned int i( 0 ); i < OverallOperations.size(); ++i)
+ delete OverallOperations[i];
+ OverallOperations.clear();
+ maLeavingSlidePrimitives.clear();
+ maEnteringSlidePrimitives.clear();
+ for(unsigned int i(0); i < maSceneObjects.size(); ++i)
+ delete maSceneObjects[i];
+ maSceneObjects.clear();
+
+ mbReflectSlides = false;
+
+#ifdef GL_VERSION_2_0
+ if( mProgramObject ) {
+ glDeleteProgram( mProgramObject );
+ mProgramObject = 0;
+ }
+
+ if( mVertexObject ) {
+ glDeleteShader( mVertexObject );
+ mVertexObject = 0;
+ }
+
+ if( mFragmentObject ) {
+ glDeleteShader( mFragmentObject );
+ mFragmentObject = 0;
+ }
+#endif
+
+ if( maHelperTexture ) {
+ glDeleteTextures( 1, &maHelperTexture );
+ maHelperTexture = 0;
+ }
+
+ if( mmClearTransition )
+ (this->*mmClearTransition)();
+}
+
+OGLTransitionImpl::~OGLTransitionImpl()
+{
+ clear();
+}
+
+void OGLTransitionImpl::prepare( ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex )
+{
+ for(unsigned int i(0); i < maSceneObjects.size(); ++i) {
+ maSceneObjects[i]->prepare();
+ }
+
+ if( mmPrepareTransition )
+ (this->*mmPrepareTransition)( glLeavingSlideTex, glEnteringSlideTex );
+}
+
+void OGLTransitionImpl::finish()
+{
+ for(unsigned int i(0); i < maSceneObjects.size(); ++i) {
+ maSceneObjects[i]->finish();
+ }
+}
+
+static void blendSlide( double depth )
+{
+ double showHeight = -1 + depth*2;
+ GLfloat reflectionColor[] = {0, 0, 0, 0.25};
+
+ glDisable( GL_DEPTH_TEST );
+ glBegin( GL_QUADS );
+ glColor4fv( reflectionColor );
+ glVertex3f( -1, -1, 0 );
+ glColor4f( 0, 0, 0, 1 );
+ glVertex3f(-1, showHeight, 0 );
+ glVertex3f( 1, showHeight, 0 );
+ glColor4fv( reflectionColor );
+ glVertex3f( 1, -1, 0 );
+ glEnd();
+
+ glBegin( GL_QUADS );
+ glColor4f( 0, 0, 0, 1 );
+ glVertex3f( -1, showHeight, 0 );
+ glVertex3f( -1, 1, 0 );
+ glVertex3f( 1, 1, 0 );
+ glVertex3f( 1, showHeight, 0 );
+ glEnd();
+ glEnable( GL_DEPTH_TEST );
+}
+
+static void slideShadow( double nTime, Primitive& primitive, double sw, double sh )
+{
+ double reflectionDepth = 0.3;
+
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glDisable(GL_LIGHTING);
+
+ glPushMatrix();
+ primitive.applyOperations( nTime, sw, sh );
+ blendSlide( reflectionDepth );
+ glPopMatrix();
+
+ glDisable(GL_BLEND);
+ glEnable(GL_LIGHTING);
+}
+
+void OGLTransitionImpl::display( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex,
+ double SlideWidth, double SlideHeight, double DispWidth, double DispHeight )
+{
+ double SlideWidthScale, SlideHeightScale;
+
+ SlideWidthScale = SlideWidth/DispWidth;
+ SlideHeightScale = SlideHeight/DispHeight;
+
+ if( mmPrepare ) {
+ clear();
+ (this->*mmPrepare)( nTime, SlideWidth, SlideHeight, DispWidth, DispHeight );
+ }
+
+ glPushMatrix();
+ displaySlides( nTime, glLeavingSlideTex, glEnteringSlideTex, SlideWidthScale, SlideHeightScale );
+ displayScene( nTime, SlideWidth, SlideHeight, DispWidth, DispHeight );
+ glPopMatrix();
+}
+
+void OGLTransitionImpl::applyOverallOperations( double nTime, double SlideWidthScale, double SlideHeightScale )
+{
+ for(unsigned int i(0); i < OverallOperations.size(); ++i)
+ OverallOperations[i]->interpolate(nTime,SlideWidthScale,SlideHeightScale);
+}
+
+void OGLTransitionImpl::displaySlide( double nTime, ::sal_Int32 glSlideTex, std::vector<Primitive>& primitives,
+ double SlideWidthScale, double SlideHeightScale )
+{
+ //TODO change to foreach
+ glBindTexture(GL_TEXTURE_2D, glSlideTex);
+
+ // display slide reflection
+ // note that depth test is turned off while blending the shadow
+ // so the slides has to be rendered in right order, see rochade as example
+ if( mbReflectSlides ) {
+ double surfaceLevel = -0.04;
+
+ /* reflected slides */
+ glPushMatrix();
+
+ glScaled( 1, -1, 1 );
+ glTranslated( 0, 2 - surfaceLevel, 0 );
+
+ glCullFace(GL_FRONT);
+ for(unsigned int i(0); i < primitives.size(); ++i)
+ primitives[i].display(nTime, SlideWidthScale, SlideHeightScale);
+ glCullFace(GL_BACK);
+
+ slideShadow( nTime, primitives[0], SlideWidthScale, SlideHeightScale );
+
+ glPopMatrix();
+ }
+
+ for(unsigned int i(0); i < primitives.size(); ++i)
+ primitives[i].display(nTime, SlideWidthScale, SlideHeightScale);
+}
+
+void OGLTransitionImpl::displaySlides( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex,
+ double SlideWidthScale, double SlideHeightScale )
+{
+ if( mmDisplaySlides )
+ (this->*mmDisplaySlides)( nTime, glLeavingSlideTex, glEnteringSlideTex, SlideWidthScale, SlideHeightScale );
+ else {
+ applyOverallOperations( nTime, SlideWidthScale, SlideHeightScale );
+
+ glEnable(GL_TEXTURE_2D);
+ displaySlide( nTime, glLeavingSlideTex, maLeavingSlidePrimitives, SlideWidthScale, SlideHeightScale );
+ displaySlide( nTime, glEnteringSlideTex, maEnteringSlidePrimitives, SlideWidthScale, SlideHeightScale );
+ }
+}
+
+void OGLTransitionImpl::displayScene( double nTime, double SlideWidth, double SlideHeight, double DispWidth, double DispHeight )
+{
+ glEnable(GL_TEXTURE_2D);
+ for(unsigned int i(0); i < maSceneObjects.size(); ++i)
+ maSceneObjects[i]->display(nTime, SlideWidth, SlideHeight, DispWidth, DispHeight);
+}
+
+void Primitive::display(double nTime, double WidthScale, double HeightScale)
+{
+ glPushMatrix();
+
+ applyOperations( nTime, WidthScale, HeightScale );
+
+ glEnableClientState( GL_VERTEX_ARRAY );
+ if(!Normals.empty())
+ {
+ glNormalPointer( GL_DOUBLE , 0 , &Normals[0] );
+ glEnableClientState( GL_NORMAL_ARRAY );
+ }
+ glEnableClientState( GL_TEXTURE_COORD_ARRAY );
+ glTexCoordPointer( 2, GL_DOUBLE, 0, &TexCoords[0] );
+ glVertexPointer( 3, GL_DOUBLE, 0, &Vertices[0] );
+ glDrawArrays( GL_TRIANGLES, 0, Vertices.size() );
+ glPopMatrix();
+}
+
+void Primitive::applyOperations(double nTime, double WidthScale, double HeightScale)
+{
+ for(unsigned int i(0); i < Operations.size(); ++i)
+ Operations[i]->interpolate( nTime ,WidthScale,HeightScale);
+ glScaled(WidthScale,HeightScale,1);
+}
+
+Primitive::~Primitive()
+{
+ for(unsigned int i( 0 ); i < Operations.size(); ++i)
+ delete Operations[i];
+}
+
+
+void SceneObject::display(double nTime, double /* SlideWidth */, double /* SlideHeight */, double DispWidth, double DispHeight )
+{
+ for(unsigned int i(0); i < maPrimitives.size(); ++i) {
+ // fixme: allow various model spaces, now we make it so that
+ // it is regular -1,-1 to 1,1, where the whole display fits in
+ glPushMatrix();
+ if (DispHeight > DispWidth)
+ glScaled(DispHeight/DispWidth, 1, 1);
+ else
+ glScaled(1, DispWidth/DispHeight, 1);
+ maPrimitives[i].display(nTime, 1, 1);
+ glPopMatrix();
+ }
+}
+
+void SceneObject::pushPrimitive(const Primitive &p)
+{
+ maPrimitives.push_back(p);
+}
+
+SceneObject::SceneObject()
+ : maPrimitives()
+{
+}
+
+Iris::Iris()
+ : SceneObject ()
+{
+}
+
+void Iris::display(double nTime, double SlideWidth, double SlideHeight, double DispWidth, double DispHeight )
+{
+ glBindTexture(GL_TEXTURE_2D, maTexture);
+ SceneObject::display(nTime, SlideWidth, SlideHeight, DispWidth, DispHeight);
+}
+
+void Iris::prepare()
+{
+ static GLubyte img[3] = { 80, 80, 80 };
+
+ glGenTextures(1, &maTexture);
+ glBindTexture(GL_TEXTURE_2D, maTexture);
+ glTexImage2D(GL_TEXTURE_2D, 0, 3, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, img);
+ glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
+ glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
+ glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
+ glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
+}
+
+void Iris::finish()
+{
+ glDeleteTextures(1, &maTexture);
+}
+
+void OGLTransitionImpl::makeOutsideCubeFaceToLeft()
+{
+ clear();
+ Primitive Slide;
+
+ Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
+ Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
+
+ maLeavingSlidePrimitives.push_back(Slide);
+
+ Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,-1),90,false,0.0,1.0));
+
+ maEnteringSlidePrimitives.push_back(Slide);
+
+ OverallOperations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,-1),-90,true,0.0,1.0));
+}
+
+void OGLTransitionImpl::makeInsideCubeFaceToLeft()
+{
+ clear();
+ Primitive Slide;
+
+ Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
+ Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
+
+ maLeavingSlidePrimitives.push_back(Slide);
+
+ Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,1),-90,false,0.0,1.0));
+
+ maEnteringSlidePrimitives.push_back(Slide);
+
+ OverallOperations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,1),90,true,0.0,1.0));
+}
+
+void OGLTransitionImpl::makeFallLeaving()
+{
+ clear();
+ Primitive Slide;
+
+ Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
+ Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
+ maEnteringSlidePrimitives.push_back(Slide);
+
+ Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(1,0,0),basegfx::B3DVector(0,-1,0), 90,true,0.0,1.0));
+ maLeavingSlidePrimitives.push_back(Slide);
+
+ mbUseMipMapEntering = false;
+}
+
+void OGLTransitionImpl::makeTurnAround()
+{
+ clear();
+ Primitive Slide;
+
+ mbReflectSlides = true;
+
+ Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
+ Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
+ maLeavingSlidePrimitives.push_back(Slide);
+
+ Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,0),-180,false,0.0,1.0));
+ maEnteringSlidePrimitives.push_back(Slide);
+
+ OverallOperations.push_back(new STranslate(basegfx::B3DVector(0, 0, -1.5),true, 0, 0.5));
+ OverallOperations.push_back(new STranslate(basegfx::B3DVector(0, 0, 1.5), true, 0.5, 1));
+ OverallOperations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0, 1, 0),basegfx::B3DVector(0, 0, 0), -180, true, 0.0, 1.0));
+}
+
+void OGLTransitionImpl::makeTurnDown()
+{
+ clear();
+ Primitive Slide;
+
+ Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
+ Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
+ maLeavingSlidePrimitives.push_back(Slide);
+
+ Slide.Operations.push_back(new STranslate(basegfx::B3DVector(0, 0, 0.0001), false, -1.0, 0.0));
+ Slide.Operations.push_back(new SRotate (basegfx::B3DVector(0, 0, 1), basegfx::B3DVector(-1, 1, 0), -90, true, 0.0, 1.0));
+ Slide.Operations.push_back(new SRotate (basegfx::B3DVector(0, 0, 1), basegfx::B3DVector(-1, 1, 0), 90, false, -1.0, 0.0));
+ maEnteringSlidePrimitives.push_back(Slide);
+
+ mbUseMipMapLeaving = false;
+}
+
+void OGLTransitionImpl::makeIris()
+{
+ clear();
+ Primitive Slide;
+
+ Slide.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0,1));
+ Slide.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (0,1), basegfx::B2DVector (1,1));
+ maEnteringSlidePrimitives.push_back (Slide);
+
+ Slide.Operations.push_back (new STranslate (basegfx::B3DVector (0, 0, 0.000001), false, -1, 0));
+ Slide.Operations.push_back (new STranslate (basegfx::B3DVector (0, 0, -0.000002), false, 0.5, 1));
+ maLeavingSlidePrimitives.push_back (Slide);
+
+
+ Primitive irisPart, part;
+ int i, nSteps = 24, nParts = 7;
+ double lt = 0, t = 1.0/nSteps, cx, cy, lcx, lcy, lx = 1, ly = 0, x, y, cxo, cyo, lcxo, lcyo, of=2.2, f=1.42;
+
+ for (i=1; i<=nSteps; i++) {
+ x = cos ((3*2*M_PI*t)/nParts);
+ y = -sin ((3*2*M_PI*t)/nParts);
+ cx = (f*x + 1)/2;
+ cy = (f*y + 1)/2;
+ lcx = (f*lx + 1)/2;
+ lcy = (f*ly + 1)/2;
+ cxo = (of*x + 1)/2;
+ cyo = (of*y + 1)/2;
+ lcxo = (of*lx + 1)/2;
+ lcyo = (of*ly + 1)/2;
+ irisPart.pushTriangle (basegfx::B2DVector (lcx, lcy),
+ basegfx::B2DVector (lcxo, lcyo),
+ basegfx::B2DVector (cx, cy));
+ irisPart.pushTriangle (basegfx::B2DVector (cx, cy),
+ basegfx::B2DVector (lcxo, lcyo),
+ basegfx::B2DVector (cxo, cyo));
+ lx = x;
+ ly = y;
+ lt = t;
+ t += 1.0/nSteps;
+ }
+
+ Iris* pIris = new Iris();
+ double angle = 87;
+
+ for (i = 0; i < nParts; i++) {
+ irisPart.Operations.clear ();
+ double rx, ry;
+
+ rx = cos ((2*M_PI*i)/nParts);
+ ry = sin ((2*M_PI*i)/nParts);
+ irisPart.Operations.push_back (new SRotate (basegfx::B3DVector(0, 0, 1), basegfx::B3DVector(rx, ry, 0), angle, true, 0.0, 0.5));
+ irisPart.Operations.push_back (new SRotate (basegfx::B3DVector(0, 0, 1), basegfx::B3DVector(rx, ry, 0), -angle, true, 0.5, 1));
+ if (i > 0) {
+ irisPart.Operations.push_back (new STranslate (basegfx::B3DVector(rx, ry, 0), false, -1, 0));
+ irisPart.Operations.push_back (new SRotate (basegfx::B3DVector(0, 0, 1), basegfx::B3DVector(0, 0, 0), i*360.0/nParts, false, -1, 0));
+ irisPart.Operations.push_back (new STranslate (basegfx::B3DVector(-1, 0, 0), false, -1, 0));
+ }
+ irisPart.Operations.push_back(new STranslate(basegfx::B3DVector(0, 0, 1), false, -2, 0.0));
+ irisPart.Operations.push_back (new SRotate (basegfx::B3DVector(1, .5, 0), basegfx::B3DVector(1, 0, 0), -30, false, -1, 0));
+ pIris->pushPrimitive (irisPart);
+ }
+
+ maSceneObjects.push_back (pIris);
+
+ mbUseMipMapLeaving = mbUseMipMapEntering = false;
+}
+
+void OGLTransitionImpl::displaySlidesRochade( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex,
+ double SlideWidthScale, double SlideHeightScale )
+{
+ applyOverallOperations( nTime, SlideWidthScale, SlideHeightScale );
+
+ glEnable(GL_TEXTURE_2D);
+
+ if( nTime > .5) {
+ displaySlide( nTime, glLeavingSlideTex, maLeavingSlidePrimitives, SlideWidthScale, SlideHeightScale );
+ displaySlide( nTime, glEnteringSlideTex, maEnteringSlidePrimitives, SlideWidthScale, SlideHeightScale );
+ } else {
+ displaySlide( nTime, glEnteringSlideTex, maEnteringSlidePrimitives, SlideWidthScale, SlideHeightScale );
+ displaySlide( nTime, glLeavingSlideTex, maLeavingSlidePrimitives, SlideWidthScale, SlideHeightScale );
+ }
+}
+
+void OGLTransitionImpl::makeRochade()
+{
+ clear();
+ Primitive Slide;
+
+ mbReflectSlides = true;
+ mmDisplaySlides = &OGLTransitionImpl::displaySlidesRochade;
+
+ double w, h;
+
+ w = 2.2;
+ h = 10;
+
+ Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
+ Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
+
+ Slide.Operations.push_back(new SEllipseTranslate(w, h, 0.25, -0.25, true, 0, 1));
+ Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,0), -45, true, 0, 1));
+ maLeavingSlidePrimitives.push_back(Slide);
+
+ Slide.Operations.clear();
+ Slide.Operations.push_back(new SEllipseTranslate(w, h, 0.75, 0.25, true, 0, 1));
+ Slide.Operations.push_back(new STranslate(basegfx::B3DVector(0, 0, -h), false, -1, 0));
+ Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,0), -45, true, 0, 1));
+ Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,0), 45, false, -1, 0));
+ maEnteringSlidePrimitives.push_back(Slide);
+
+ // OverallOperations.push_back(new SEllipseTranslate(0.5, 2, 0, 1, true, 0, 1));
+// push_back(new STranslate(basegfx::B3DVector(0, 0, -2), true, 0, 0.5));
+// OverallOperations.push_back(new STranslate(basegfx::B3DVector(0, 0, 2), true, 0.5, 1));
+}
+
+// TODO(Q3): extract to basegfx
+inline basegfx::B2DVector clamp(const basegfx::B2DVector& v)
+{
+ return basegfx::B2DVector(min(max(v.getX(),-1.0),1.0),
+ min(max(v.getY(),-1.0),1.0));
+}
+
+// TODO(Q3): extract to basegfx
+inline basegfx::B3DVector clamp(const basegfx::B3DVector& v)
+{
+ return basegfx::B3DVector(min(max(v.getX(),-1.0),1.0),
+ min(max(v.getY(),-1.0),1.0),
+ min(max(v.getZ(),-1.0),1.0));
+}
+
+inline double randFromNeg1to1()
+{
+ return ( ( static_cast<double>( rand() ) / static_cast<double>( RAND_MAX ) ) * 2.0 ) - 1.0;
+}
+
+// TODO(Q3): extract to basegfx
+inline basegfx::B3DVector randNormVectorInXYPlane()
+{
+ basegfx::B3DVector toReturn(randFromNeg1to1(),randFromNeg1to1(),0.0);
+ return toReturn/toReturn.getLength();
+}
+
+void OGLTransitionImpl::makeRevolvingCircles( ::sal_uInt16 nCircles , ::sal_uInt16 nPointsOnCircles )
+{
+ clear();
+ double dAngle(2*3.1415926/static_cast<double>( nPointsOnCircles ));
+ if(nCircles < 2 || nPointsOnCircles < 4)
+ {
+ makeNByMTileFlip(1,1);
+ return;
+ }
+ double Radius(1.0/static_cast<double>( nCircles ));
+ double dRadius(Radius);
+ double LastRadius(0.0);
+ double NextRadius(2*Radius);
+
+ /// now we know there is at least two circles
+ /// the first will always be a full circle
+ /// the last will always be the outer shell of the slide with a circle hole
+
+ //add the full circle
+ vector<basegfx::B2DVector> unScaledTexCoords;
+ double TempAngle(0.0);
+ for(unsigned int Point(0); Point < nPointsOnCircles; ++Point)
+ {
+ unScaledTexCoords.push_back( basegfx::B2DVector( cos(TempAngle - 3.1415926/2.0) , sin(TempAngle- 3.1415926/2.0) ) );
+
+ TempAngle += dAngle;
+ }
+
+ {
+ //double angle(0.0);
+ Primitive EnteringSlide;
+ Primitive LeavingSlide;
+ for(int Point(0); Point + 1 < nPointsOnCircles; ++Point)
+ {
+ EnteringSlide.pushTriangle( basegfx::B2DVector( 0.5 , 0.5 ) , Radius * unScaledTexCoords[ Point + 1 ] / 2.0 + basegfx::B2DVector( 0.5 , 0.5 ) , Radius * unScaledTexCoords[ Point ] / 2.0 + basegfx::B2DVector( 0.5 , 0.5 ) );
+ LeavingSlide.pushTriangle( basegfx::B2DVector( 0.5 , 0.5 ) , Radius * unScaledTexCoords[ Point + 1 ] / 2.0 + basegfx::B2DVector( 0.5 , 0.5 ) , Radius * unScaledTexCoords[ Point ] / 2.0 + basegfx::B2DVector( 0.5, 0.5) );
+ }
+ EnteringSlide.pushTriangle( basegfx::B2DVector(0.5,0.5) , Radius * unScaledTexCoords[ 0 ] / 2.0 + basegfx::B2DVector( 0.5 , 0.5 ) , Radius * unScaledTexCoords[ nPointsOnCircles - 1 ] / 2.0 + basegfx::B2DVector( 0.5 , 0.5 ) );
+ LeavingSlide.pushTriangle( basegfx::B2DVector(0.5,0.5) , Radius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) , Radius*unScaledTexCoords[nPointsOnCircles - 1]/2.0 + basegfx::B2DVector(0.5,0.5) );
+
+ basegfx::B3DVector axis(randNormVectorInXYPlane());
+ EnteringSlide.Operations.push_back( new SRotate( axis , basegfx::B3DVector(0,0,0) , 180, true, Radius/2.0 , (NextRadius + 1)/2.0 ) );
+ LeavingSlide.Operations.push_back( new SRotate( axis , basegfx::B3DVector(0,0,0) , 180, true, Radius/2.0 , (NextRadius + 1)/2.0 ) );
+ EnteringSlide.Operations.push_back( new SRotate( axis , basegfx::B3DVector(0,0,0) , -180, false,0.0,1.0) );
+
+ maEnteringSlidePrimitives.push_back(EnteringSlide);
+ maLeavingSlidePrimitives.push_back(LeavingSlide);
+ LastRadius = Radius;
+ Radius = NextRadius;
+ NextRadius += dRadius;
+ }
+
+ for(int i(1); i < nCircles - 1; ++i)
+ {
+ Primitive LeavingSlide;
+ Primitive EnteringSlide;
+ for(int Side(0); Side < nPointsOnCircles - 1; ++Side)
+ {
+ EnteringSlide.pushTriangle(Radius*unScaledTexCoords[Side]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0 + basegfx::B2DVector(0.5,0.5) );
+ EnteringSlide.pushTriangle(Radius*unScaledTexCoords[Side]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0 + basegfx::B2DVector(0.5,0.5) , Radius*unScaledTexCoords[Side + 1]/2.0 + basegfx::B2DVector(0.5,0.5) );
+
+ LeavingSlide.pushTriangle(Radius*unScaledTexCoords[Side]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0 + basegfx::B2DVector(0.5,0.5) );
+ LeavingSlide.pushTriangle(Radius*unScaledTexCoords[Side]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0 + basegfx::B2DVector(0.5,0.5) , Radius*unScaledTexCoords[Side + 1]/2.0 + basegfx::B2DVector(0.5,0.5) );
+ }
+
+ EnteringSlide.pushTriangle(Radius*unScaledTexCoords[nPointsOnCircles - 1]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[nPointsOnCircles - 1]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) );
+ EnteringSlide.pushTriangle(Radius*unScaledTexCoords[nPointsOnCircles - 1]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) , Radius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) );
+
+ LeavingSlide.pushTriangle(Radius*unScaledTexCoords[nPointsOnCircles - 1]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[nPointsOnCircles - 1]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) );
+ LeavingSlide.pushTriangle(Radius*unScaledTexCoords[nPointsOnCircles - 1]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) , Radius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) );
+
+ basegfx::B3DVector axis(randNormVectorInXYPlane());
+ EnteringSlide.Operations.push_back( new SRotate( axis , basegfx::B3DVector(0,0,0) , 180, true, Radius/2.0 , (NextRadius + 1)/2.0 ) );
+ LeavingSlide.Operations.push_back( new SRotate( axis , basegfx::B3DVector(0,0,0) , 180, true, Radius/2.0 , (NextRadius + 1)/2.0 ) );
+ EnteringSlide.Operations.push_back( new SRotate( axis , basegfx::B3DVector(0,0,0) , -180, false,0.0,1.0) );
+
+ maEnteringSlidePrimitives.push_back(EnteringSlide);
+ maLeavingSlidePrimitives.push_back(LeavingSlide);
+
+ LastRadius = Radius;
+ Radius = NextRadius;
+ NextRadius += dRadius;
+ }
+ {
+ Radius = sqrt(2.0);
+ Primitive LeavingSlide;
+ Primitive EnteringSlide;
+ for(int Side(0); Side < nPointsOnCircles - 1; ++Side)
+ {
+
+ EnteringSlide.pushTriangle(clamp(Radius*unScaledTexCoords[Side])/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0 + basegfx::B2DVector(0.5,0.5) );
+ EnteringSlide.pushTriangle(clamp(Radius*unScaledTexCoords[Side])/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0 + basegfx::B2DVector(0.5,0.5) , clamp(Radius*unScaledTexCoords[Side + 1])/2.0 + basegfx::B2DVector(0.5,0.5) );
+
+ LeavingSlide.pushTriangle(clamp(Radius*unScaledTexCoords[Side])/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0 + basegfx::B2DVector(0.5,0.5) );
+ LeavingSlide.pushTriangle(clamp(Radius*unScaledTexCoords[Side])/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0 + basegfx::B2DVector(0.5,0.5) , clamp(Radius*unScaledTexCoords[Side + 1])/2.0 + basegfx::B2DVector(0.5,0.5) );
+ }
+
+ EnteringSlide.pushTriangle(clamp(Radius*unScaledTexCoords[nPointsOnCircles - 1])/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[nPointsOnCircles - 1]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) );
+ EnteringSlide.pushTriangle(clamp(Radius*unScaledTexCoords[nPointsOnCircles - 1])/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) , clamp(Radius*unScaledTexCoords[0])/2.0 + basegfx::B2DVector(0.5,0.5) );
+
+ LeavingSlide.pushTriangle(clamp(Radius*unScaledTexCoords[nPointsOnCircles - 1])/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[nPointsOnCircles - 1]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) );
+ LeavingSlide.pushTriangle(clamp(Radius*unScaledTexCoords[nPointsOnCircles - 1])/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) , clamp(Radius*unScaledTexCoords[0])/2.0 + basegfx::B2DVector(0.5,0.5) );
+
+ basegfx::B3DVector axis(randNormVectorInXYPlane());
+ EnteringSlide.Operations.push_back( new SRotate( axis , basegfx::B3DVector(0,0,0) , 180, true, (LastRadius + dRadius)/2.0 , 1.0 ) );
+ LeavingSlide.Operations.push_back( new SRotate( axis , basegfx::B3DVector(0,0,0) , 180, true, (LastRadius + dRadius)/2.0 , 1.0 ) );
+ EnteringSlide.Operations.push_back( new SRotate( axis , basegfx::B3DVector(0,0,0) , -180, false,0.0,1.0) );
+
+ maEnteringSlidePrimitives.push_back(EnteringSlide);
+ maLeavingSlidePrimitives.push_back(LeavingSlide);
+ }
+}
+
+void OGLTransitionImpl::makeHelix( ::sal_uInt16 nRows )
+{
+ clear();
+ double invN(1.0/static_cast<double>(nRows));
+ double iDn = 0.0;
+ double iPDn = invN;
+ for(unsigned int i(0); i < nRows; ++i)
+ {
+ Primitive Tile;
+
+ Tile.pushTriangle(basegfx::B2DVector( 1.0 , iDn ) , basegfx::B2DVector( 0.0 , iDn ) , basegfx::B2DVector( 0.0 , iPDn ));
+
+ Tile.pushTriangle(basegfx::B2DVector( 1.0 , iPDn ) , basegfx::B2DVector( 1.0 , iDn ) , basegfx::B2DVector( 0.0 , iPDn ));
+
+ Tile.Operations.push_back( new SRotate( basegfx::B3DVector( 0 , 1 , 0 ) , ( Tile.getVertices()[1] + Tile.getVertices()[3] )/2.0 , 180 ,
+ true,min(max(static_cast<double>(i - nRows/2.0)*invN/2.0,0.0),1.0),
+ min(max(static_cast<double>(i + nRows/2.0)*invN/2.0,0.0),1.0) ) );
+
+ maLeavingSlidePrimitives.push_back(Tile);
+
+ Tile.Operations.push_back( new SRotate( basegfx::B3DVector( 0 , 1 , 0 ) , ( Tile.getVertices()[1] + Tile.getVertices()[3] )/2.0 , -180 , false,0.0,1.0) );
+
+ maEnteringSlidePrimitives.push_back(Tile);
+
+ iDn += invN;
+ iPDn += invN;
+ }
+}
+
+void OGLTransitionImpl::makeNByMTileFlip( ::sal_uInt16 n, ::sal_uInt16 m )
+{
+ clear();
+ double invN(1.0/static_cast<double>(n));
+ double invM(1.0/static_cast<double>(m));
+ double iDn = 0.0;
+ double iPDn = invN;
+ for(unsigned int i(0); i < n; ++i)
+ {
+ double jDm = 0.0;
+ double jPDm = invM;
+ for(unsigned int j(0); j < m; ++j)
+ {
+ Primitive Tile;
+
+ Tile.pushTriangle(basegfx::B2DVector( iPDn , jDm ) , basegfx::B2DVector( iDn , jDm ) , basegfx::B2DVector( iDn , jPDm ));
+
+ Tile.pushTriangle(basegfx::B2DVector( iPDn , jPDm ) , basegfx::B2DVector( iPDn , jDm ) , basegfx::B2DVector( iDn , jPDm ));//bottom left corner of tile
+
+ Tile.Operations.push_back( new SRotate( basegfx::B3DVector( 1 , 1 , 0 ) , ( Tile.getVertices()[1] + Tile.getVertices()[3] )/2.0 , 180 , true, iDn*jDm/2.0 , ((iPDn*jPDm)+1.0)/2.0 ) );
+ maLeavingSlidePrimitives.push_back(Tile);
+ Tile.Operations.push_back( new SRotate( basegfx::B3DVector( 1 , 1 , 0 ) , ( Tile.getVertices()[1] + Tile.getVertices()[3] )/2.0 , -180, false, iDn*jDm/2.0 , ((iPDn*jPDm)+1.0)/2.0 ) );
+
+ maEnteringSlidePrimitives.push_back(Tile);
+
+ jDm += invM;
+ jPDm += invM;
+ }
+ iDn += invN;
+ iPDn += invN;
+ }
+}
+
+SRotate::SRotate(const basegfx::B3DVector& Axis,const basegfx::B3DVector& Origin,double Angle, bool bInter, double T0, double T1):axis(Axis),origin(Origin),angle(Angle)
+{
+ nT0 = T0;
+ nT1 = T1;
+ bInterpolate = bInter;
+}
+
+SScale::SScale(const basegfx::B3DVector& Scale,const basegfx::B3DVector& Origin, bool bInter, double T0, double T1):scale(Scale),origin(Origin)
+{
+ nT0 = T0;
+ nT1 = T1;
+ bInterpolate = bInter;
+}
+
+RotateAndScaleDepthByWidth::RotateAndScaleDepthByWidth(const basegfx::B3DVector& Axis,const basegfx::B3DVector& Origin,double Angle, bool bInter, double T0, double T1):axis(Axis),origin(Origin),angle(Angle)
+{
+ nT0 = T0;
+ nT1 = T1;
+ bInterpolate = bInter;
+}
+
+RotateAndScaleDepthByHeight::RotateAndScaleDepthByHeight(const basegfx::B3DVector& Axis,const basegfx::B3DVector& Origin,double Angle, bool bInter, double T0, double T1):axis(Axis),origin(Origin),angle(Angle)
+{
+ nT0 = T0;
+ nT1 = T1;
+ bInterpolate = bInter;
+}
+
+
+STranslate::STranslate(const basegfx::B3DVector& Vector, bool bInter, double T0, double T1):vector(Vector)
+{
+ nT0 = T0;
+ nT1 = T1;
+ bInterpolate = bInter;
+}
+
+inline double intervalInter(double t, double T0, double T1)
+{
+ return ( t - T0 ) / ( T1 - T0 );
+}
+
+void STranslate::interpolate(double t,double SlideWidthScale,double SlideHeightScale)
+{
+ if(t <= nT0)
+ return;
+ if(!bInterpolate || t > nT1)
+ t = nT1;
+ t = intervalInter(t,nT0,nT1);
+ glTranslated(SlideWidthScale*t*vector.getX(),SlideHeightScale*t*vector.getY(),t*vector.getZ());
+}
+
+void SRotate::interpolate(double t,double SlideWidthScale,double SlideHeightScale)
+{
+ if(t <= nT0)
+ return;
+ if(!bInterpolate || t > nT1)
+ t = nT1;
+ t = intervalInter(t,nT0,nT1);
+ glTranslated(SlideWidthScale*origin.getX(),SlideHeightScale*origin.getY(),origin.getZ());
+ glScaled(SlideWidthScale,SlideHeightScale,1);
+ glRotated(t*angle,axis.getX(),axis.getY(),axis.getZ());
+ glScaled(1/SlideWidthScale,1/SlideHeightScale,1);
+ glTranslated(-SlideWidthScale*origin.getX(),-SlideHeightScale*origin.getY(),-origin.getZ());
+}
+
+void SScale::interpolate(double t,double SlideWidthScale,double SlideHeightScale)
+{
+ if(t <= nT0)
+ return;
+ if(!bInterpolate || t > nT1)
+ t = nT1;
+ t = intervalInter(t,nT0,nT1);
+ glTranslated(SlideWidthScale*origin.getX(),SlideHeightScale*origin.getY(),origin.getZ());
+ glScaled((1-t) + t*scale.getX(),(1-t) + t*scale.getY(),(1-t) + t*scale.getZ());
+ glTranslated(-SlideWidthScale*origin.getX(),-SlideHeightScale*origin.getY(),-origin.getZ());
+}
+
+void RotateAndScaleDepthByWidth::interpolate(double t,double SlideWidthScale,double SlideHeightScale)
+{
+ if(t <= nT0)
+ return;
+ if(!bInterpolate || t > nT1)
+ t = nT1;
+ t = intervalInter(t,nT0,nT1);
+ glTranslated(SlideWidthScale*origin.getX(),SlideHeightScale*origin.getY(),SlideWidthScale*origin.getZ());
+ glRotated(t*angle,axis.getX(),axis.getY(),axis.getZ());
+ glTranslated(-SlideWidthScale*origin.getX(),-SlideHeightScale*origin.getY(),-SlideWidthScale*origin.getZ());
+}
+
+void RotateAndScaleDepthByHeight::interpolate(double t,double SlideWidthScale,double SlideHeightScale)
+{
+ if(t <= nT0)
+ return;
+ if(!bInterpolate || t > nT1)
+ t = nT1;
+ t = intervalInter(t,nT0,nT1);
+ glTranslated(SlideWidthScale*origin.getX(),SlideHeightScale*origin.getY(),SlideHeightScale*origin.getZ());
+ glRotated(t*angle,axis.getX(),axis.getY(),axis.getZ());
+ glTranslated(-SlideWidthScale*origin.getX(),-SlideHeightScale*origin.getY(),-SlideHeightScale*origin.getZ());
+}
+
+SEllipseTranslate::SEllipseTranslate(double dWidth, double dHeight, double dStartPosition, double dEndPosition, bool bInter, double T0, double T1)
+{
+ nT0 = T0;
+ nT1 = T1;
+ bInterpolate = bInter;
+ width = dWidth;
+ height = dHeight;
+ startPosition = dStartPosition;
+ endPosition = dEndPosition;
+}
+
+void SEllipseTranslate::interpolate(double t,double /* SlideWidthScale */,double /* SlideHeightScale */)
+{
+ if(t <= nT0)
+ return;
+ if(!bInterpolate || t > nT1)
+ t = nT1;
+ t = intervalInter(t,nT0,nT1);
+
+ double a1, a2, x, y;
+ a1 = startPosition*2*M_PI;
+ a2 = (startPosition + t*(endPosition - startPosition))*2*M_PI;
+ x = width*(cos (a2) - cos (a1))/2;
+ y = height*(sin (a2) - sin (a1))/2;
+
+ glTranslated(x, 0, y);
+}
+
+STranslate* STranslate::clone()
+{
+ return new STranslate(*this);
+}
+SRotate* SRotate::clone()
+{
+ return new SRotate(*this);
+}
+
+SScale* SScale::clone()
+{
+ return new SScale(*this);
+}
+
+SEllipseTranslate* SEllipseTranslate::clone()
+{
+ return new SEllipseTranslate(*this);
+}
+
+RotateAndScaleDepthByWidth* RotateAndScaleDepthByWidth::clone()
+{
+ return new RotateAndScaleDepthByWidth(*this);
+}
+
+RotateAndScaleDepthByHeight* RotateAndScaleDepthByHeight::clone()
+{
+ return new RotateAndScaleDepthByHeight(*this);
+}
+
+const Primitive& Primitive::operator=(const Primitive& rvalue)
+{
+ for(unsigned int i( 0 ); i < rvalue.Operations.size(); ++i)
+ Operations.push_back(rvalue.Operations[i]->clone());
+ for(unsigned int i( 0 ); i < rvalue.Vertices.size(); ++i)//SPEED! use copy or something. this is slow.
+ Vertices.push_back(rvalue.Vertices[i]);
+ for(unsigned int i( 0 ); i < rvalue.TexCoords.size(); ++i)//SPEED! use copy or something. this is slow.
+ TexCoords.push_back(rvalue.TexCoords[i]);
+ for(unsigned int i( 0 ); i < rvalue.Normals.size(); ++i)//SPEED! use copy or something. this is slow.
+ Normals.push_back(rvalue.Normals[i]);
+ return *this;
+}
+
+Primitive::Primitive(const Primitive& rvalue)
+{
+ for(unsigned int i( 0 ); i < rvalue.Operations.size(); ++i)
+ Operations.push_back(rvalue.Operations[i]->clone());
+ for(unsigned int i( 0 ); i < rvalue.Vertices.size(); ++i)//SPEED! use copy or something. this is slow.
+ Vertices.push_back(rvalue.Vertices[i]);
+ for(unsigned int i( 0 ); i < rvalue.TexCoords.size(); ++i)//SPEED! use copy or something. this is slow.
+ TexCoords.push_back(rvalue.TexCoords[i]);
+ for(unsigned int i( 0 ); i < rvalue.Normals.size(); ++i)//SPEED! use copy or something. this is slow.
+ Normals.push_back(rvalue.Normals[i]);
+}
+
+void Primitive::pushTriangle(const basegfx::B2DVector& SlideLocation0,const basegfx::B2DVector& SlideLocation1,const basegfx::B2DVector& SlideLocation2)
+{
+ vector<basegfx::B3DVector> Verts;
+ vector<basegfx::B2DVector> Texs;
+ Verts.reserve(3);
+ Texs.reserve(3);
+
+ Verts.push_back(basegfx::B3DVector( 2*SlideLocation0.getX() - 1, -2*SlideLocation0.getY() + 1 , 0.0 ));
+ Verts.push_back(basegfx::B3DVector( 2*SlideLocation1.getX() - 1, -2*SlideLocation1.getY() + 1 , 0.0 ));
+ Verts.push_back(basegfx::B3DVector( 2*SlideLocation2.getX() - 1, -2*SlideLocation2.getY() + 1 , 0.0 ));
+
+ //figure out if they're facing the correct way, and make them face the correct way.
+ basegfx::B3DVector Normal( basegfx::cross( Verts[0] - Verts[1] , Verts[1] - Verts[2] ) );
+ if(Normal.getZ() >= 0.0)//if the normal is facing us
+ {
+ Texs.push_back(SlideLocation0);
+ Texs.push_back(SlideLocation1);
+ Texs.push_back(SlideLocation2);
+ }
+ else // if the normal is facing away from us, make it face us
+ {
+ Texs.push_back(SlideLocation0);
+ Texs.push_back(SlideLocation2);
+ Texs.push_back(SlideLocation1);
+ Verts.clear();
+ Verts.push_back(basegfx::B3DVector( 2*SlideLocation0.getX() - 1, -2*SlideLocation0.getY() + 1 , 0.0 ));
+ Verts.push_back(basegfx::B3DVector( 2*SlideLocation2.getX() - 1, -2*SlideLocation2.getY() + 1 , 0.0 ));
+ Verts.push_back(basegfx::B3DVector( 2*SlideLocation1.getX() - 1, -2*SlideLocation1.getY() + 1 , 0.0 ));
+ }
+
+ Vertices.push_back(Verts[0]);
+ Vertices.push_back(Verts[1]);
+ Vertices.push_back(Verts[2]);
+
+ TexCoords.push_back(Texs[0]);
+ TexCoords.push_back(Texs[1]);
+ TexCoords.push_back(Texs[2]);
+
+ Normals.push_back(basegfx::B3DVector(0,0,1));//all normals always face the screen when untransformed.
+ Normals.push_back(basegfx::B3DVector(0,0,1));//all normals always face the screen when untransformed.
+ Normals.push_back(basegfx::B3DVector(0,0,1));//all normals always face the screen when untransformed.
+}
+
+void OGLTransitionImpl::makeDiamond()
+{
+ mmPrepare = &OGLTransitionImpl::prepareDiamond;
+ mbUseMipMapLeaving = mbUseMipMapEntering = false;
+}
+
+void OGLTransitionImpl::prepareDiamond( double nTime, double /* SlideWidth */, double /* SlideHeight */, double /* DispWidth */, double /* DispHeight */ )
+{
+ Primitive Slide1, Slide2;
+
+ Slide1.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0,1));
+ Slide1.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (0,1), basegfx::B2DVector (1,1));
+ maEnteringSlidePrimitives.push_back (Slide1);
+
+
+ if( nTime >= 0.5 ) {
+ double m = 1 - nTime;
+
+ Slide2.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (m,0), basegfx::B2DVector (0,m));
+ Slide2.pushTriangle (basegfx::B2DVector (nTime,0), basegfx::B2DVector (1,0), basegfx::B2DVector (1,m));
+ Slide2.pushTriangle (basegfx::B2DVector (1,nTime), basegfx::B2DVector (1,1), basegfx::B2DVector (nTime,1));
+ Slide2.pushTriangle (basegfx::B2DVector (0,nTime), basegfx::B2DVector (m,1), basegfx::B2DVector (0,1));
+ } else {
+ double l = 0.5 - nTime;
+ double h = 0.5 + nTime;
+
+ Slide2.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0.5,l));
+ Slide2.pushTriangle (basegfx::B2DVector (0.5,l), basegfx::B2DVector (1,0), basegfx::B2DVector (h,0.5));
+ Slide2.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (1,1), basegfx::B2DVector (h,0.5));
+ Slide2.pushTriangle (basegfx::B2DVector (h,0.5), basegfx::B2DVector (1,1), basegfx::B2DVector (0.5,h));
+ Slide2.pushTriangle (basegfx::B2DVector (0.5,h), basegfx::B2DVector (1,1), basegfx::B2DVector (0,1));
+ Slide2.pushTriangle (basegfx::B2DVector (l,0.5), basegfx::B2DVector (0.5,h), basegfx::B2DVector (0,1));
+ Slide2.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (l,0.5), basegfx::B2DVector (0,1));
+ Slide2.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (0.5,l), basegfx::B2DVector (l,0.5));
+ }
+ Slide2.Operations.push_back (new STranslate (basegfx::B3DVector (0, 0, 0.00000001), false, -1, 0));
+ maLeavingSlidePrimitives.push_back (Slide2);
+}
+
+void OGLTransitionImpl::makeVenetianBlinds( bool vertical, int parts )
+{
+ static double t30 = tan( M_PI/6.0 );
+ double n, ln = 0;
+ double p = 1.0/parts;
+
+ for( int i=0; i<parts; i++ ) {
+ Primitive Slide;
+ n = (i + 1)/(double)parts;
+ if( vertical ) {
+ Slide.pushTriangle (basegfx::B2DVector (ln,0), basegfx::B2DVector (n,0), basegfx::B2DVector (ln,1));
+ Slide.pushTriangle (basegfx::B2DVector (n,0), basegfx::B2DVector (ln,1), basegfx::B2DVector (n,1));
+ Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0, 1, 0), basegfx::B3DVector(n + ln - 1, 0, -t30*p), -120, true, 0.0, 1.0));
+ } else {
+ Slide.pushTriangle (basegfx::B2DVector (0,ln), basegfx::B2DVector (1,ln), basegfx::B2DVector (0,n));
+ Slide.pushTriangle (basegfx::B2DVector (1,ln), basegfx::B2DVector (0,n), basegfx::B2DVector (1,n));
+ Slide.Operations.push_back(new RotateAndScaleDepthByHeight(basegfx::B3DVector(1, 0, 0), basegfx::B3DVector(0, 1 - n - ln, -t30*p), -120, true, 0.0, 1.0));
+ }
+ maLeavingSlidePrimitives.push_back (Slide);
+
+ if( vertical ) {
+ Slide.Operations.push_back(new SRotate(basegfx::B3DVector(0, 1, 0), basegfx::B3DVector(2*n - 1, 0, 0), -60, false, -1, 0));
+ Slide.Operations.push_back(new SRotate(basegfx::B3DVector(0, 1, 0), basegfx::B3DVector(n + ln - 1, 0, 0), 180, false, -1, 0));
+ } else {
+ Slide.Operations.push_back(new SRotate(basegfx::B3DVector(1, 0, 0), basegfx::B3DVector(0, 1 - 2*n, 0), -60, false, -1, 0));
+ Slide.Operations.push_back(new SRotate(basegfx::B3DVector(1, 0, 0), basegfx::B3DVector(0, 1 - n - ln, 0), 180, false, -1, 0));
+ }
+ maEnteringSlidePrimitives.push_back (Slide);
+ ln = n;
+ }
+}
+
+void OGLTransitionImpl::displaySlidesFadeSmoothly( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex, double SlideWidthScale, double SlideHeightScale )
+{
+ applyOverallOperations( nTime, SlideWidthScale, SlideHeightScale );
+
+ glDisable(GL_DEPTH_TEST);
+
+ displaySlide( nTime, glLeavingSlideTex, maLeavingSlidePrimitives, SlideWidthScale, SlideHeightScale );
+
+ glDisable(GL_LIGHTING);
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+ glColor4f( 1, 1, 1, nTime );
+ displaySlide( nTime, glEnteringSlideTex, maEnteringSlidePrimitives, SlideWidthScale, SlideHeightScale );
+ glDisable(GL_BLEND);
+ glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+ glEnable(GL_LIGHTING);
+
+ glEnable(GL_DEPTH_TEST);
+}
+
+void OGLTransitionImpl::makeFadeSmoothly()
+{
+ Primitive Slide;
+
+ Slide.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0,1));
+ Slide.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (0,1), basegfx::B2DVector (1,1));
+ maLeavingSlidePrimitives.push_back (Slide);
+ maEnteringSlidePrimitives.push_back (Slide);
+
+ mmDisplaySlides = &OGLTransitionImpl::displaySlidesFadeSmoothly;
+ mbUseMipMapLeaving = mbUseMipMapEntering = false;
+}
+
+void OGLTransitionImpl::displaySlidesFadeThroughBlack( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex, double SlideWidthScale, double SlideHeightScale )
+{
+ applyOverallOperations( nTime, SlideWidthScale, SlideHeightScale );
+
+ glDisable(GL_DEPTH_TEST);
+
+ glDisable(GL_LIGHTING);
+ glEnable(GL_BLEND);
+ glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+ glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
+ if( nTime < 0.5 ) {
+ glColor4f( 1, 1, 1, 1 - nTime*2 );
+ displaySlide( nTime, glLeavingSlideTex, maLeavingSlidePrimitives, SlideWidthScale, SlideHeightScale );
+ } else {
+ glColor4f( 1, 1, 1, (nTime - 0.5)*2 );
+ displaySlide( nTime, glEnteringSlideTex, maEnteringSlidePrimitives, SlideWidthScale, SlideHeightScale );
+ }
+ glDisable(GL_BLEND);
+ glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
+ glEnable(GL_LIGHTING);
+
+ glEnable(GL_DEPTH_TEST);
+}
+
+void OGLTransitionImpl::makeFadeThroughBlack()
+{
+ Primitive Slide;
+
+ Slide.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0,1));
+ Slide.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (0,1), basegfx::B2DVector (1,1));
+ maLeavingSlidePrimitives.push_back (Slide);
+ maEnteringSlidePrimitives.push_back (Slide);
+
+ mmDisplaySlides = &OGLTransitionImpl::displaySlidesFadeThroughBlack;
+ mbUseMipMapLeaving = mbUseMipMapEntering = false;
+}
+
+static const char* basicVertexShader = "\n\
+varying vec2 v_texturePosition;\n\
+\n\
+void main( void )\n\
+{\n\
+ gl_Position = ftransform();\n\
+ v_texturePosition = gl_MultiTexCoord0.xy;\n\
+}\n\
+";
+
+static const char* staticFragmentShader = "\n\
+uniform sampler2D leavingSlideTexture;\n\
+uniform sampler2D enteringSlideTexture;\n\
+uniform sampler2D permTexture;\n\
+uniform float time;\n\
+varying vec2 v_texturePosition;\n\
+\n\
+float snoise(vec2 P) {\n\
+\n\
+ return texture2D(permTexture, P).r;\n\
+}\n\
+\n\
+\n\
+#define PART 0.5\n\
+#define START 0.4\n\
+#define END 0.9\n\
+\n\
+void main() {\n\
+ float sn = snoise(10.0*v_texturePosition+time*0.07);\n\
+ if( time < PART ) {\n\
+ float sn1 = snoise(vec2(time*15.0, 20.0*v_texturePosition.y));\n\
+ float sn2 = snoise(v_texturePosition);\n\
+ if (sn1 > 1.0 - time*time && sn2 < 2.0*time+0.1)\n\
+ gl_FragColor = vec4(sn, sn, sn, 1.0);\n\
+ else if (time > START )\n\
+ gl_FragColor = ((time-START)/(PART - START))*vec4(sn, sn, sn, 1.0) + (1.0 - (time - START)/(PART - START))*texture2D(leavingSlideTexture, v_texturePosition);\n\
+ else\n\
+ gl_FragColor = texture2D(leavingSlideTexture, v_texturePosition);\n\
+ } else if ( time < PART ) {\n\
+ gl_FragColor = texture2D(leavingSlideTexture, v_texturePosition);\n\
+ } else if ( time > END ) {\n\
+ gl_FragColor = ((1.0 - time)/(1.0 - END))*vec4(sn, sn, sn, 1.0) + ((time - END)/(1.0 - END))*texture2D(enteringSlideTexture, v_texturePosition);\n\
+ } else \n\
+ gl_FragColor = vec4(sn, sn, sn, 1.0);\n\
+}\n\
+";
+
+static const char* dissolveFragmentShader = "\n\
+uniform sampler2D leavingSlideTexture;\n\
+uniform sampler2D enteringSlideTexture;\n\
+uniform sampler2D permTexture;\n\
+uniform float time;\n\
+varying vec2 v_texturePosition;\n\
+\n\
+float snoise(vec2 P) {\n\
+\n\
+ return texture2D(permTexture, P).r;\n\
+}\n\
+\n\
+void main() {\n\
+ float sn = snoise(10.0*v_texturePosition);\n\
+ if( sn < time)\n\
+ gl_FragColor = texture2D(enteringSlideTexture, v_texturePosition);\n\
+ else\n\
+ gl_FragColor = texture2D(leavingSlideTexture, v_texturePosition);\n\
+}\n\
+";
+
+int permutation256 [256]= {
+215, 100, 200, 204, 233, 50, 85, 196,
+ 71, 141, 122, 160, 93, 131, 243, 234,
+162, 183, 36, 155, 4, 62, 35, 205,
+ 40, 102, 33, 27, 255, 55, 214, 156,
+ 75, 163, 134, 126, 249, 74, 197, 228,
+ 72, 90, 206, 235, 17, 22, 49, 169,
+227, 89, 16, 5, 117, 60, 248, 230,
+217, 68, 138, 96, 194, 170, 136, 10,
+112, 238, 184, 189, 176, 42, 225, 212,
+ 84, 58, 175, 244, 150, 168, 219, 236,
+101, 208, 123, 37, 164, 110, 158, 201,
+ 78, 114, 57, 48, 70, 142, 106, 43,
+232, 26, 32, 252, 239, 98, 191, 94,
+ 59, 149, 39, 187, 203, 190, 19, 13,
+133, 45, 61, 247, 23, 34, 20, 52,
+118, 209, 146, 193, 222, 18, 1, 152,
+ 46, 41, 91, 148, 115, 25, 135, 77,
+254, 147, 224, 161, 9, 213, 223, 250,
+231, 251, 127, 166, 63, 179, 81, 130,
+139, 28, 120, 151, 241, 86, 111, 0,
+ 88, 153, 172, 182, 159, 105, 178, 47,
+ 51, 167, 65, 66, 92, 73, 198, 211,
+245, 195, 31, 220, 140, 76, 221, 186,
+154, 185, 56, 83, 38, 165, 109, 67,
+124, 226, 132, 53, 229, 29, 12, 181,
+121, 24, 207, 199, 177, 113, 30, 80,
+ 3, 97, 188, 79, 216, 173, 8, 145,
+ 87, 128, 180, 237, 240, 137, 125, 104,
+ 15, 242, 119, 246, 103, 143, 95, 144,
+ 2, 44, 69, 157, 192, 174, 14, 54,
+218, 82, 64, 210, 11, 6, 129, 21,
+116, 171, 99, 202, 7, 107, 253, 108
+};
+
+void initPermTexture(GLuint *texID)
+{
+ glGenTextures(1, texID);
+ glBindTexture(GL_TEXTURE_2D, *texID);
+
+ static bool initialized = false;
+ static unsigned char permutation2D[256*256*4];
+ if( !initialized ) {
+ int x, y;
+
+ for( y=0; y < 256; y++ )
+ for( x=0; x < 256; x++ )
+ permutation2D[x*4 + y*1024] = permutation256[(y + permutation256[x]) & 0xff];
+
+ initialized = true;
+ }
+
+ glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, permutation2D );
+ glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST );
+ glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST );
+}
+
+void OGLTransitionImpl::preparePermShader()
+{
+#ifdef GL_VERSION_2_0
+ if( mProgramObject ) {
+ glUseProgram( mProgramObject );
+
+ GLint location = glGetUniformLocation( mProgramObject, "leavingSlideTexture" );
+ if( location != -1 ) {
+ glUniform1i( location, 0 ); // texture unit 0
+ }
+
+ glActiveTexture(GL_TEXTURE1);
+ if( !maHelperTexture )
+ initPermTexture( &maHelperTexture );
+ glActiveTexture(GL_TEXTURE0);
+
+ location = glGetUniformLocation( mProgramObject, "permTexture" );
+ if( location != -1 ) {
+ glUniform1i( location, 1 ); // texture unit 1
+ }
+
+ location = glGetUniformLocation( mProgramObject, "enteringSlideTexture" );
+ if( location != -1 ) {
+ glUniform1i( location, 2 ); // texture unit 2
+ }
+ }
+#endif
+}
+
+void OGLTransitionImpl::prepareStatic( ::sal_Int32 /* glLeavingSlideTex */, ::sal_Int32 /* glEnteringSlideTex */ )
+{
+ //mProgramObject = LinkProgram( basicVertexShader, staticFragmentShader );
+ NSString * _basicVertexShader = (NSString *) basicVertexShader;
+ NSString * _staticFragmentShader = (NSString *) staticFragmentShader;
+ OGLShaders * anOGLShader = NULL;
+ mProgramObject = [anOGLShader loadVertexShader: _basicVertexShader fragmentShader: _staticFragmentShader];
+
+ preparePermShader();
+}
+
+void OGLTransitionImpl::displaySlidesShaders( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex,
+ double SlideWidthScale, double SlideHeightScale )
+{
+ applyOverallOperations( nTime, SlideWidthScale, SlideHeightScale );
+
+#ifdef GL_VERSION_2_0
+ if( mProgramObject ) {
+ GLint location = glGetUniformLocation( mProgramObject, "time" );
+ if( location != -1 ) {
+ glUniform1f( location, nTime );
+ }
+ }
+
+ glActiveTexture( GL_TEXTURE2 );
+ glBindTexture( GL_TEXTURE_2D, glEnteringSlideTex );
+ glActiveTexture( GL_TEXTURE0 );
+#endif
+
+ displaySlide( nTime, glLeavingSlideTex, maLeavingSlidePrimitives, SlideWidthScale, SlideHeightScale );
+}
+
+void OGLTransitionImpl::makeStatic()
+{
+ Primitive Slide;
+
+ Slide.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0,1));
+ Slide.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (0,1), basegfx::B2DVector (1,1));
+ maLeavingSlidePrimitives.push_back (Slide);
+ maEnteringSlidePrimitives.push_back (Slide);
+
+ mmDisplaySlides = &OGLTransitionImpl::displaySlidesShaders;
+ mmPrepareTransition = &OGLTransitionImpl::prepareStatic;
+ mbUseMipMapLeaving = mbUseMipMapEntering = false;
+
+ mnRequiredGLVersion = 2.0;
+}
+
+void OGLTransitionImpl::prepareDissolve( ::sal_Int32 /* glLeavingSlideTex */, ::sal_Int32 /* glEnteringSlideTex */ )
+{
+ NSString * _basicVertexShader = (NSString *) basicVertexShader;
+ NSString * _dissolveFragmentShader = (NSString *) dissolveFragmentShader;
+// mProgramObject = loadVertexShader( _basicVertexShader, _dissolveFragmentShader );
+ OGLShaders * anOGLShader = NULL;
+ mProgramObject = [anOGLShader loadVertexShader: _basicVertexShader fragmentShader: _dissolveFragmentShader];
+
+ preparePermShader();
+}
+
+void OGLTransitionImpl::makeDissolve()
+{
+ Primitive Slide;
+
+ Slide.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0,1));
+ Slide.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (0,1), basegfx::B2DVector (1,1));
+ maLeavingSlidePrimitives.push_back (Slide);
+ maEnteringSlidePrimitives.push_back (Slide);
+
+ mmDisplaySlides = &OGLTransitionImpl::displaySlidesShaders;
+ mmPrepareTransition = &OGLTransitionImpl::prepareDissolve;
+ mbUseMipMapLeaving = mbUseMipMapEntering = false;
+
+ mnRequiredGLVersion = 2.0;
+}
+
+void OGLTransitionImpl::makeNewsflash()
+{
+ Primitive Slide;
+
+ Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
+ Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
+ Slide.Operations.push_back(new SRotate(basegfx::B3DVector(0,0,1),basegfx::B3DVector(0,0,0),3000,true,0,0.5));
+ Slide.Operations.push_back(new SScale(basegfx::B3DVector(0.01,0.01,0.01),basegfx::B3DVector(0,0,0),true,0,0.5));
+ Slide.Operations.push_back(new STranslate(basegfx::B3DVector(-10000, 0, 0),false, 0.5, 2));
+ maLeavingSlidePrimitives.push_back(Slide);
+
+ Slide.Operations.clear();
+ Slide.Operations.push_back(new SRotate(basegfx::B3DVector(0,0,1),basegfx::B3DVector(0,0,0),-3000,true,0.5,1));
+ Slide.Operations.push_back(new STranslate(basegfx::B3DVector(-100, 0, 0),false, -1, 1));
+ Slide.Operations.push_back(new STranslate(basegfx::B3DVector(100, 0, 0),false, 0.5, 1));
+ Slide.Operations.push_back(new SScale(basegfx::B3DVector(0.01,0.01,0.01),basegfx::B3DVector(0,0,0),false,-1,1));
+ Slide.Operations.push_back(new SScale(basegfx::B3DVector(100,100,100),basegfx::B3DVector(0,0,0),true,0.5,1));
+ maEnteringSlidePrimitives.push_back(Slide);
+
+ OverallOperations.push_back(new SRotate(basegfx::B3DVector(0,0,1),basegfx::B3DVector(0.2,0.2,0),1080,true,0,1));
+}
+
diff --git a/slideshow/source/engine/OGLTrans/mac/OGLTrans_TransitionImpl_MACOSX.mm b/slideshow/source/engine/OGLTrans/mac/OGLTrans_TransitionImpl_MACOSX.mm
deleted file mode 100644
index 6686980..0000000
--- a/slideshow/source/engine/OGLTrans/mac/OGLTrans_TransitionImpl_MACOSX.mm
+++ /dev/null
@@ -1,1329 +0,0 @@
-/*************************************************************************
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * Copyright 2008 by Sun Microsystems, Inc.
- *
- * OpenOffice.org - a multi-platform office productivity suite
- *
- * $RCSfile: OGLTrans_TransitionImpl.cxx,v $
- * $Revision: 1.5.12.1 $
- *
- * This file is part of OpenOffice.org.
- *
- * OpenOffice.org is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 3
- * only, as published by the Free Software Foundation.
- *
- * OpenOffice.org is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU Lesser General Public License version 3 for more details
- * (a copy is included in the LICENSE file that accompanied this code).
- *
- * You should have received a copy of the GNU Lesser General Public License
- * version 3 along with OpenOffice.org. If not, see
- * <http://www.openoffice.org/license.html>
- * for a copy of the LGPLv3 License.
- *
- ************************************************************************/
-
-#include "OGLTrans_TransitionImpl.hxx"
-#include "OGLTrans_Shaders_MACOSX.h"
-#ifdef QUARTZ
-#include <OpenGL/gl.h>
-#else
-#include <GL/gl.h>
-#endif
-#include <math.h>
-
-void OGLTransitionImpl::clear()
-{
- for(unsigned int i( 0 ); i < OverallOperations.size(); ++i)
- delete OverallOperations[i];
- OverallOperations.clear();
- maLeavingSlidePrimitives.clear();
- maEnteringSlidePrimitives.clear();
- for(unsigned int i(0); i < maSceneObjects.size(); ++i)
- delete maSceneObjects[i];
- maSceneObjects.clear();
-
- mbReflectSlides = false;
-
-#ifdef GL_VERSION_2_0
- if( mProgramObject ) {
- glDeleteProgram( mProgramObject );
- mProgramObject = 0;
- }
-
- if( mVertexObject ) {
- glDeleteShader( mVertexObject );
- mVertexObject = 0;
- }
-
- if( mFragmentObject ) {
- glDeleteShader( mFragmentObject );
- mFragmentObject = 0;
- }
-#endif
-
- if( maHelperTexture ) {
- glDeleteTextures( 1, &maHelperTexture );
- maHelperTexture = 0;
- }
-
- if( mmClearTransition )
- (this->*mmClearTransition)();
-}
-
-OGLTransitionImpl::~OGLTransitionImpl()
-{
- clear();
-}
-
-void OGLTransitionImpl::prepare( ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex )
-{
- for(unsigned int i(0); i < maSceneObjects.size(); ++i) {
- maSceneObjects[i]->prepare();
- }
-
- if( mmPrepareTransition )
- (this->*mmPrepareTransition)( glLeavingSlideTex, glEnteringSlideTex );
-}
-
-void OGLTransitionImpl::finish()
-{
- for(unsigned int i(0); i < maSceneObjects.size(); ++i) {
- maSceneObjects[i]->finish();
- }
-}
-
-static void blendSlide( double depth )
-{
- double showHeight = -1 + depth*2;
- GLfloat reflectionColor[] = {0, 0, 0, 0.25};
-
- glDisable( GL_DEPTH_TEST );
- glBegin( GL_QUADS );
- glColor4fv( reflectionColor );
- glVertex3f( -1, -1, 0 );
- glColor4f( 0, 0, 0, 1 );
- glVertex3f(-1, showHeight, 0 );
- glVertex3f( 1, showHeight, 0 );
- glColor4fv( reflectionColor );
- glVertex3f( 1, -1, 0 );
- glEnd();
-
- glBegin( GL_QUADS );
- glColor4f( 0, 0, 0, 1 );
- glVertex3f( -1, showHeight, 0 );
- glVertex3f( -1, 1, 0 );
- glVertex3f( 1, 1, 0 );
- glVertex3f( 1, showHeight, 0 );
- glEnd();
- glEnable( GL_DEPTH_TEST );
-}
-
-static void slideShadow( double nTime, Primitive& primitive, double sw, double sh )
-{
- double reflectionDepth = 0.3;
-
- glEnable(GL_BLEND);
- glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
- glDisable(GL_LIGHTING);
-
- glPushMatrix();
- primitive.applyOperations( nTime, sw, sh );
- blendSlide( reflectionDepth );
- glPopMatrix();
-
- glDisable(GL_BLEND);
- glEnable(GL_LIGHTING);
-}
-
-void OGLTransitionImpl::display( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex,
- double SlideWidth, double SlideHeight, double DispWidth, double DispHeight )
-{
- double SlideWidthScale, SlideHeightScale;
-
- SlideWidthScale = SlideWidth/DispWidth;
- SlideHeightScale = SlideHeight/DispHeight;
-
- if( mmPrepare ) {
- clear();
- (this->*mmPrepare)( nTime, SlideWidth, SlideHeight, DispWidth, DispHeight );
- }
-
- glPushMatrix();
- displaySlides( nTime, glLeavingSlideTex, glEnteringSlideTex, SlideWidthScale, SlideHeightScale );
- displayScene( nTime, SlideWidth, SlideHeight, DispWidth, DispHeight );
- glPopMatrix();
-}
-
-void OGLTransitionImpl::applyOverallOperations( double nTime, double SlideWidthScale, double SlideHeightScale )
-{
- for(unsigned int i(0); i < OverallOperations.size(); ++i)
- OverallOperations[i]->interpolate(nTime,SlideWidthScale,SlideHeightScale);
-}
-
-void OGLTransitionImpl::displaySlide( double nTime, ::sal_Int32 glSlideTex, std::vector<Primitive>& primitives,
- double SlideWidthScale, double SlideHeightScale )
-{
- //TODO change to foreach
- glBindTexture(GL_TEXTURE_2D, glSlideTex);
-
- // display slide reflection
- // note that depth test is turned off while blending the shadow
- // so the slides has to be rendered in right order, see rochade as example
- if( mbReflectSlides ) {
- double surfaceLevel = -0.04;
-
- /* reflected slides */
- glPushMatrix();
-
- glScaled( 1, -1, 1 );
- glTranslated( 0, 2 - surfaceLevel, 0 );
-
- glCullFace(GL_FRONT);
- for(unsigned int i(0); i < primitives.size(); ++i)
- primitives[i].display(nTime, SlideWidthScale, SlideHeightScale);
- glCullFace(GL_BACK);
-
- slideShadow( nTime, primitives[0], SlideWidthScale, SlideHeightScale );
-
- glPopMatrix();
- }
-
- for(unsigned int i(0); i < primitives.size(); ++i)
- primitives[i].display(nTime, SlideWidthScale, SlideHeightScale);
-}
-
-void OGLTransitionImpl::displaySlides( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex,
- double SlideWidthScale, double SlideHeightScale )
-{
- if( mmDisplaySlides )
- (this->*mmDisplaySlides)( nTime, glLeavingSlideTex, glEnteringSlideTex, SlideWidthScale, SlideHeightScale );
- else {
- applyOverallOperations( nTime, SlideWidthScale, SlideHeightScale );
-
- glEnable(GL_TEXTURE_2D);
- displaySlide( nTime, glLeavingSlideTex, maLeavingSlidePrimitives, SlideWidthScale, SlideHeightScale );
- displaySlide( nTime, glEnteringSlideTex, maEnteringSlidePrimitives, SlideWidthScale, SlideHeightScale );
- }
-}
-
-void OGLTransitionImpl::displayScene( double nTime, double SlideWidth, double SlideHeight, double DispWidth, double DispHeight )
-{
- glEnable(GL_TEXTURE_2D);
- for(unsigned int i(0); i < maSceneObjects.size(); ++i)
- maSceneObjects[i]->display(nTime, SlideWidth, SlideHeight, DispWidth, DispHeight);
-}
-
-void Primitive::display(double nTime, double WidthScale, double HeightScale)
-{
- glPushMatrix();
-
- applyOperations( nTime, WidthScale, HeightScale );
-
- glEnableClientState( GL_VERTEX_ARRAY );
- if(!Normals.empty())
- {
- glNormalPointer( GL_DOUBLE , 0 , &Normals[0] );
- glEnableClientState( GL_NORMAL_ARRAY );
- }
- glEnableClientState( GL_TEXTURE_COORD_ARRAY );
- glTexCoordPointer( 2, GL_DOUBLE, 0, &TexCoords[0] );
- glVertexPointer( 3, GL_DOUBLE, 0, &Vertices[0] );
- glDrawArrays( GL_TRIANGLES, 0, Vertices.size() );
- glPopMatrix();
-}
-
-void Primitive::applyOperations(double nTime, double WidthScale, double HeightScale)
-{
- for(unsigned int i(0); i < Operations.size(); ++i)
- Operations[i]->interpolate( nTime ,WidthScale,HeightScale);
- glScaled(WidthScale,HeightScale,1);
-}
-
-Primitive::~Primitive()
-{
- for(unsigned int i( 0 ); i < Operations.size(); ++i)
- delete Operations[i];
-}
-
-
-void SceneObject::display(double nTime, double /* SlideWidth */, double /* SlideHeight */, double DispWidth, double DispHeight )
-{
- for(unsigned int i(0); i < maPrimitives.size(); ++i) {
- // fixme: allow various model spaces, now we make it so that
- // it is regular -1,-1 to 1,1, where the whole display fits in
- glPushMatrix();
- if (DispHeight > DispWidth)
- glScaled(DispHeight/DispWidth, 1, 1);
- else
- glScaled(1, DispWidth/DispHeight, 1);
- maPrimitives[i].display(nTime, 1, 1);
- glPopMatrix();
- }
-}
-
-void SceneObject::pushPrimitive(const Primitive &p)
-{
- maPrimitives.push_back(p);
-}
-
-SceneObject::SceneObject()
- : maPrimitives()
-{
-}
-
-Iris::Iris()
- : SceneObject ()
-{
-}
-
-void Iris::display(double nTime, double SlideWidth, double SlideHeight, double DispWidth, double DispHeight )
-{
- glBindTexture(GL_TEXTURE_2D, maTexture);
- SceneObject::display(nTime, SlideWidth, SlideHeight, DispWidth, DispHeight);
-}
-
-void Iris::prepare()
-{
- static GLubyte img[3] = { 80, 80, 80 };
-
- glGenTextures(1, &maTexture);
- glBindTexture(GL_TEXTURE_2D, maTexture);
- glTexImage2D(GL_TEXTURE_2D, 0, 3, 1, 1, 0, GL_RGB, GL_UNSIGNED_BYTE, img);
- glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_REPEAT);
- glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T,GL_REPEAT);
- glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR);
- glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
-}
-
-void Iris::finish()
-{
- glDeleteTextures(1, &maTexture);
-}
-
-void OGLTransitionImpl::makeOutsideCubeFaceToLeft()
-{
- clear();
- Primitive Slide;
-
- Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
- Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
-
- maLeavingSlidePrimitives.push_back(Slide);
-
- Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,-1),90,false,0.0,1.0));
-
- maEnteringSlidePrimitives.push_back(Slide);
-
- OverallOperations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,-1),-90,true,0.0,1.0));
-}
-
-void OGLTransitionImpl::makeInsideCubeFaceToLeft()
-{
- clear();
- Primitive Slide;
-
- Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
- Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
-
- maLeavingSlidePrimitives.push_back(Slide);
-
- Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,1),-90,false,0.0,1.0));
-
- maEnteringSlidePrimitives.push_back(Slide);
-
- OverallOperations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,1),90,true,0.0,1.0));
-}
-
-void OGLTransitionImpl::makeFallLeaving()
-{
- clear();
- Primitive Slide;
-
- Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
- Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
- maEnteringSlidePrimitives.push_back(Slide);
-
- Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(1,0,0),basegfx::B3DVector(0,-1,0), 90,true,0.0,1.0));
- maLeavingSlidePrimitives.push_back(Slide);
-
- mbUseMipMapEntering = false;
-}
-
-void OGLTransitionImpl::makeTurnAround()
-{
- clear();
- Primitive Slide;
-
- mbReflectSlides = true;
-
- Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
- Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
- maLeavingSlidePrimitives.push_back(Slide);
-
- Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,0),-180,false,0.0,1.0));
- maEnteringSlidePrimitives.push_back(Slide);
-
- OverallOperations.push_back(new STranslate(basegfx::B3DVector(0, 0, -1.5),true, 0, 0.5));
- OverallOperations.push_back(new STranslate(basegfx::B3DVector(0, 0, 1.5), true, 0.5, 1));
- OverallOperations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0, 1, 0),basegfx::B3DVector(0, 0, 0), -180, true, 0.0, 1.0));
-}
-
-void OGLTransitionImpl::makeTurnDown()
-{
- clear();
- Primitive Slide;
-
- Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
- Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
- maLeavingSlidePrimitives.push_back(Slide);
-
- Slide.Operations.push_back(new STranslate(basegfx::B3DVector(0, 0, 0.0001), false, -1.0, 0.0));
- Slide.Operations.push_back(new SRotate (basegfx::B3DVector(0, 0, 1), basegfx::B3DVector(-1, 1, 0), -90, true, 0.0, 1.0));
- Slide.Operations.push_back(new SRotate (basegfx::B3DVector(0, 0, 1), basegfx::B3DVector(-1, 1, 0), 90, false, -1.0, 0.0));
- maEnteringSlidePrimitives.push_back(Slide);
-
- mbUseMipMapLeaving = false;
-}
-
-void OGLTransitionImpl::makeIris()
-{
- clear();
- Primitive Slide;
-
- Slide.pushTriangle (basegfx::B2DVector (0,0), basegfx::B2DVector (1,0), basegfx::B2DVector (0,1));
- Slide.pushTriangle (basegfx::B2DVector (1,0), basegfx::B2DVector (0,1), basegfx::B2DVector (1,1));
- maEnteringSlidePrimitives.push_back (Slide);
-
- Slide.Operations.push_back (new STranslate (basegfx::B3DVector (0, 0, 0.000001), false, -1, 0));
- Slide.Operations.push_back (new STranslate (basegfx::B3DVector (0, 0, -0.000002), false, 0.5, 1));
- maLeavingSlidePrimitives.push_back (Slide);
-
-
- Primitive irisPart, part;
- int i, nSteps = 24, nParts = 7;
- double lt = 0, t = 1.0/nSteps, cx, cy, lcx, lcy, lx = 1, ly = 0, x, y, cxo, cyo, lcxo, lcyo, of=2.2, f=1.42;
-
- for (i=1; i<=nSteps; i++) {
- x = cos ((3*2*M_PI*t)/nParts);
- y = -sin ((3*2*M_PI*t)/nParts);
- cx = (f*x + 1)/2;
- cy = (f*y + 1)/2;
- lcx = (f*lx + 1)/2;
- lcy = (f*ly + 1)/2;
- cxo = (of*x + 1)/2;
- cyo = (of*y + 1)/2;
- lcxo = (of*lx + 1)/2;
- lcyo = (of*ly + 1)/2;
- irisPart.pushTriangle (basegfx::B2DVector (lcx, lcy),
- basegfx::B2DVector (lcxo, lcyo),
- basegfx::B2DVector (cx, cy));
- irisPart.pushTriangle (basegfx::B2DVector (cx, cy),
- basegfx::B2DVector (lcxo, lcyo),
- basegfx::B2DVector (cxo, cyo));
- lx = x;
- ly = y;
- lt = t;
- t += 1.0/nSteps;
- }
-
- Iris* pIris = new Iris();
- double angle = 87;
-
- for (i = 0; i < nParts; i++) {
- irisPart.Operations.clear ();
- double rx, ry;
-
- rx = cos ((2*M_PI*i)/nParts);
- ry = sin ((2*M_PI*i)/nParts);
- irisPart.Operations.push_back (new SRotate (basegfx::B3DVector(0, 0, 1), basegfx::B3DVector(rx, ry, 0), angle, true, 0.0, 0.5));
- irisPart.Operations.push_back (new SRotate (basegfx::B3DVector(0, 0, 1), basegfx::B3DVector(rx, ry, 0), -angle, true, 0.5, 1));
- if (i > 0) {
- irisPart.Operations.push_back (new STranslate (basegfx::B3DVector(rx, ry, 0), false, -1, 0));
- irisPart.Operations.push_back (new SRotate (basegfx::B3DVector(0, 0, 1), basegfx::B3DVector(0, 0, 0), i*360.0/nParts, false, -1, 0));
- irisPart.Operations.push_back (new STranslate (basegfx::B3DVector(-1, 0, 0), false, -1, 0));
- }
- irisPart.Operations.push_back(new STranslate(basegfx::B3DVector(0, 0, 1), false, -2, 0.0));
- irisPart.Operations.push_back (new SRotate (basegfx::B3DVector(1, .5, 0), basegfx::B3DVector(1, 0, 0), -30, false, -1, 0));
- pIris->pushPrimitive (irisPart);
- }
-
- maSceneObjects.push_back (pIris);
-
- mbUseMipMapLeaving = mbUseMipMapEntering = false;
-}
-
-void OGLTransitionImpl::displaySlidesRochade( double nTime, ::sal_Int32 glLeavingSlideTex, ::sal_Int32 glEnteringSlideTex,
- double SlideWidthScale, double SlideHeightScale )
-{
- applyOverallOperations( nTime, SlideWidthScale, SlideHeightScale );
-
- glEnable(GL_TEXTURE_2D);
-
- if( nTime > .5) {
- displaySlide( nTime, glLeavingSlideTex, maLeavingSlidePrimitives, SlideWidthScale, SlideHeightScale );
- displaySlide( nTime, glEnteringSlideTex, maEnteringSlidePrimitives, SlideWidthScale, SlideHeightScale );
- } else {
- displaySlide( nTime, glEnteringSlideTex, maEnteringSlidePrimitives, SlideWidthScale, SlideHeightScale );
- displaySlide( nTime, glLeavingSlideTex, maLeavingSlidePrimitives, SlideWidthScale, SlideHeightScale );
- }
-}
-
-void OGLTransitionImpl::makeRochade()
-{
- clear();
- Primitive Slide;
-
- mbReflectSlides = true;
- mmDisplaySlides = &OGLTransitionImpl::displaySlidesRochade;
-
- double w, h;
-
- w = 2.2;
- h = 10;
-
- Slide.pushTriangle(basegfx::B2DVector(0,0),basegfx::B2DVector(1,0),basegfx::B2DVector(0,1));
- Slide.pushTriangle(basegfx::B2DVector(1,0),basegfx::B2DVector(0,1),basegfx::B2DVector(1,1));
-
- Slide.Operations.push_back(new SEllipseTranslate(w, h, 0.25, -0.25, true, 0, 1));
- Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,0), -45, true, 0, 1));
- maLeavingSlidePrimitives.push_back(Slide);
-
- Slide.Operations.clear();
- Slide.Operations.push_back(new SEllipseTranslate(w, h, 0.75, 0.25, true, 0, 1));
- Slide.Operations.push_back(new STranslate(basegfx::B3DVector(0, 0, -h), false, -1, 0));
- Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,0), -45, true, 0, 1));
- Slide.Operations.push_back(new RotateAndScaleDepthByWidth(basegfx::B3DVector(0,1,0),basegfx::B3DVector(0,0,0), 45, false, -1, 0));
- maEnteringSlidePrimitives.push_back(Slide);
-
- // OverallOperations.push_back(new SEllipseTranslate(0.5, 2, 0, 1, true, 0, 1));
-// push_back(new STranslate(basegfx::B3DVector(0, 0, -2), true, 0, 0.5));
-// OverallOperations.push_back(new STranslate(basegfx::B3DVector(0, 0, 2), true, 0.5, 1));
-}
-
-// TODO(Q3): extract to basegfx
-inline basegfx::B2DVector clamp(const basegfx::B2DVector& v)
-{
- return basegfx::B2DVector(min(max(v.getX(),-1.0),1.0),
- min(max(v.getY(),-1.0),1.0));
-}
-
-// TODO(Q3): extract to basegfx
-inline basegfx::B3DVector clamp(const basegfx::B3DVector& v)
-{
- return basegfx::B3DVector(min(max(v.getX(),-1.0),1.0),
- min(max(v.getY(),-1.0),1.0),
- min(max(v.getZ(),-1.0),1.0));
-}
-
-inline double randFromNeg1to1()
-{
- return ( ( static_cast<double>( rand() ) / static_cast<double>( RAND_MAX ) ) * 2.0 ) - 1.0;
-}
-
-// TODO(Q3): extract to basegfx
-inline basegfx::B3DVector randNormVectorInXYPlane()
-{
- basegfx::B3DVector toReturn(randFromNeg1to1(),randFromNeg1to1(),0.0);
- return toReturn/toReturn.getLength();
-}
-
-void OGLTransitionImpl::makeRevolvingCircles( ::sal_uInt16 nCircles , ::sal_uInt16 nPointsOnCircles )
-{
- clear();
- double dAngle(2*3.1415926/static_cast<double>( nPointsOnCircles ));
- if(nCircles < 2 || nPointsOnCircles < 4)
- {
- makeNByMTileFlip(1,1);
- return;
- }
- double Radius(1.0/static_cast<double>( nCircles ));
- double dRadius(Radius);
- double LastRadius(0.0);
- double NextRadius(2*Radius);
-
- /// now we know there is at least two circles
- /// the first will always be a full circle
- /// the last will always be the outer shell of the slide with a circle hole
-
- //add the full circle
- vector<basegfx::B2DVector> unScaledTexCoords;
- double TempAngle(0.0);
- for(unsigned int Point(0); Point < nPointsOnCircles; ++Point)
- {
- unScaledTexCoords.push_back( basegfx::B2DVector( cos(TempAngle - 3.1415926/2.0) , sin(TempAngle- 3.1415926/2.0) ) );
-
- TempAngle += dAngle;
- }
-
- {
- //double angle(0.0);
- Primitive EnteringSlide;
- Primitive LeavingSlide;
- for(int Point(0); Point + 1 < nPointsOnCircles; ++Point)
- {
- EnteringSlide.pushTriangle( basegfx::B2DVector( 0.5 , 0.5 ) , Radius * unScaledTexCoords[ Point + 1 ] / 2.0 + basegfx::B2DVector( 0.5 , 0.5 ) , Radius * unScaledTexCoords[ Point ] / 2.0 + basegfx::B2DVector( 0.5 , 0.5 ) );
- LeavingSlide.pushTriangle( basegfx::B2DVector( 0.5 , 0.5 ) , Radius * unScaledTexCoords[ Point + 1 ] / 2.0 + basegfx::B2DVector( 0.5 , 0.5 ) , Radius * unScaledTexCoords[ Point ] / 2.0 + basegfx::B2DVector( 0.5, 0.5) );
- }
- EnteringSlide.pushTriangle( basegfx::B2DVector(0.5,0.5) , Radius * unScaledTexCoords[ 0 ] / 2.0 + basegfx::B2DVector( 0.5 , 0.5 ) , Radius * unScaledTexCoords[ nPointsOnCircles - 1 ] / 2.0 + basegfx::B2DVector( 0.5 , 0.5 ) );
- LeavingSlide.pushTriangle( basegfx::B2DVector(0.5,0.5) , Radius*unScaledTexCoords[0]/2.0 + basegfx::B2DVector(0.5,0.5) , Radius*unScaledTexCoords[nPointsOnCircles - 1]/2.0 + basegfx::B2DVector(0.5,0.5) );
-
- basegfx::B3DVector axis(randNormVectorInXYPlane());
- EnteringSlide.Operations.push_back( new SRotate( axis , basegfx::B3DVector(0,0,0) , 180, true, Radius/2.0 , (NextRadius + 1)/2.0 ) );
- LeavingSlide.Operations.push_back( new SRotate( axis , basegfx::B3DVector(0,0,0) , 180, true, Radius/2.0 , (NextRadius + 1)/2.0 ) );
- EnteringSlide.Operations.push_back( new SRotate( axis , basegfx::B3DVector(0,0,0) , -180, false,0.0,1.0) );
-
- maEnteringSlidePrimitives.push_back(EnteringSlide);
- maLeavingSlidePrimitives.push_back(LeavingSlide);
- LastRadius = Radius;
- Radius = NextRadius;
- NextRadius += dRadius;
- }
-
- for(int i(1); i < nCircles - 1; ++i)
- {
- Primitive LeavingSlide;
- Primitive EnteringSlide;
- for(int Side(0); Side < nPointsOnCircles - 1; ++Side)
- {
- EnteringSlide.pushTriangle(Radius*unScaledTexCoords[Side]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side]/2.0 + basegfx::B2DVector(0.5,0.5) , LastRadius*unScaledTexCoords[Side + 1]/2.0 + basegfx::B2DVector(0.5,0.5) );
... etc. - the rest is truncated
More information about the Libreoffice-commits
mailing list