| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| #include "OGLTrans_TransitionImpl.hxx" |
| #include "OGLTrans_Shaders.hxx" |
| #include <GL/gl.h> |
| #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 ) { |
| OGLShaders::glDeleteProgram( mProgramObject ); |
| mProgramObject = 0; |
| } |
| |
| if( mVertexObject ) { |
| OGLShaders::glDeleteShader( mVertexObject ); |
| mVertexObject = 0; |
| } |
| |
| if( mFragmentObject ) { |
| OGLShaders::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 ) { |
| OGLShaders::glUseProgram( mProgramObject ); |
| |
| GLint location = OGLShaders::glGetUniformLocation( mProgramObject, "leavingSlideTexture" ); |
| if( location != -1 ) { |
| OGLShaders::glUniform1i( location, 0 ); // texture unit 0 |
| } |
| |
| glActiveTexture(GL_TEXTURE1); |
| if( !maHelperTexture ) |
| initPermTexture( &maHelperTexture ); |
| glActiveTexture(GL_TEXTURE0); |
| |
| location = OGLShaders::glGetUniformLocation( mProgramObject, "permTexture" ); |
| if( location != -1 ) { |
| OGLShaders::glUniform1i( location, 1 ); // texture unit 1 |
| } |
| |
| location = OGLShaders::glGetUniformLocation( mProgramObject, "enteringSlideTexture" ); |
| if( location != -1 ) { |
| OGLShaders::glUniform1i( location, 2 ); // texture unit 2 |
| } |
| } |
| #endif |
| } |
| |
| void OGLTransitionImpl::prepareStatic( ::sal_Int32 /* glLeavingSlideTex */, ::sal_Int32 /* glEnteringSlideTex */ ) |
| { |
| mProgramObject = OGLShaders::LinkProgram( basicVertexShader, 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 = OGLShaders::glGetUniformLocation( mProgramObject, "time" ); |
| if( location != -1 ) { |
| OGLShaders::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 */ ) |
| { |
| mProgramObject = OGLShaders::LinkProgram( basicVertexShader, 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)); |
| } |
| |
