/**************************************************************
*
* 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));
}