Tank::Tank(QObject *parent)
: QGLSceneNode(parent)
, m_texture(0)
{
QSequentialAnimationGroup *seq = new QSequentialAnimationGroup(this);
QGraphicsScale3D *scale = new QGraphicsScale3D(this);
addTransform(scale);
QPropertyAnimation *anim = new QPropertyAnimation(scale, "scale");
anim->setDuration(10000);
anim->setStartValue(QVector3D(1.0f, 0.1f, 1.0f));
anim->setEndValue(QVector3D(1.0f, 1.2f, 1.0f));
anim->setEasingCurve(QEasingCurve(QEasingCurve::InOutQuad));
seq->addAnimation(anim);
seq->addPause(2000);
anim = new QPropertyAnimation(scale, "scale");
anim->setDuration(10000);
anim->setStartValue(QVector3D(1.0f, 1.2f, 1.0f));
anim->setEndValue(QVector3D(1.0f, 0.1f, 1.0f));
anim->setEasingCurve(QEasingCurve(QEasingCurve::InOutQuad));
seq->addAnimation(anim);
seq->setLoopCount(-1);
seq->start();
addNode(tankObject());
QGLMaterial *mat = qCreateFluid();
m_texture = mat->texture();
setMaterial(mat);
}
StereoView::StereoView(QWidget *parent)
: QGLView(parent)
{
scene = new QGLSceneNode(this);
QGLSceneNode *teapot;
QGLSceneNode *cube;
{
QGLBuilder builder;
builder << QGLTeapot();
teapot = builder.finalizedSceneNode();
}
{
QGLBuilder builder;
builder.newSection(QGL::Faceted);
builder << QGLCube(1.0f);
cube = builder.finalizedSceneNode();
}
cube->setPosition(QVector3D(-1.0f, 0.0f, 2.0f));
scene->addNode(teapot);
scene->addNode(cube);
QGLMaterial *china = new QGLMaterial(this);
china->setAmbientColor(QColor(192, 150, 128));
china->setSpecularColor(QColor(60, 60, 60));
china->setShininess(128);
scene->setMaterial(china);
scene->setEffect(QGL::LitMaterial);
camera()->setEye(QVector3D(0.0f, 0.0f, 15.0f));
camera()->setEyeSeparation(0.2f);
}
void tst_QGLRender::values()
{
QGLSceneNode node; // by default has QGL::FlatColor
QGLSceneNode node2;
QSharedPointer<QGLMaterialCollection> pal(new QGLMaterialCollection());
node.setPalette(pal);
node2.setPalette(pal);
node2.setEffect(QGL::LitMaterial);
QGLRenderState s;
QGLRenderOrder order(&node, s);
QGLRenderOrder other(&node2, s);
QGLRenderOrderComparator cmp;
QVERIFY(!cmp.isEqualTo(other, order));
QVERIFY(cmp.isLessThan(order, other));
QGLRenderState state;
QGLMaterial *mat = new QGLMaterial;
mat->setAmbientColor(Qt::blue);
int ix = pal->addMaterial(mat);
QGLSceneNode node3;
node3.setPalette(pal);
node3.setMaterialIndex(ix);
node3.setEffect(QGL::LitMaterial);
state.updateFrom(&node3);
QGLRenderOrder other2(&node, state);
QVERIFY(other2.effectiveHasEffect());
QCOMPARE(other2.effectiveMaterial(), mat);
QCOMPARE(other2.effectiveStandardEffect(), QGL::LitMaterial);
QCOMPARE(other2.effectiveUserEffect(), (QGLAbstractEffect*)0);
QVERIFY(cmp.isLessThan(order, other2));
QVERIFY(cmp.isLessThan(other, other2));
}
coordinates::coordinates( float size, float thickness ):
m_node( new QGLSceneNode() )
{
QGLBuilder builder;
builder << QGLCylinder( thickness, thickness, size, 12 );
QGLSceneNode* cylinder = builder.finalizedSceneNode();
cylinder->setPosition( QVector3D( 0, 0, 0.5 * size ) );
cylinder->setEffect( QGL::LitMaterial );
QGLBuilder arrowBuilder;
arrowBuilder << QGLCylinder( 0.01, 2 * thickness, size / 3, 12 );
QGLSceneNode* arrow = arrowBuilder.finalizedSceneNode();
arrow->setPosition( QVector3D( 0, 0, size ) );
arrow->setEffect( QGL::LitMaterial );
QGLSceneNode* x = new QGLSceneNode( m_node );
x->addNode(cylinder);
QMatrix4x4 matrix;
QQuaternion q = QQuaternion::fromAxisAndAngle(0.0f, 1.0f, 0.0f, 90.0f);
matrix.rotate( q );
x->setLocalTransform( matrix );
QGLSceneNode* xArrow = new QGLSceneNode( m_node );
xArrow->addNode( arrow );
xArrow->setLocalTransform( matrix );
QGLMaterial* xMaterial = new QGLMaterial;
xMaterial->setDiffuseColor( QColor( 255, 0, 0, 128 ) );
x->setMaterial( xMaterial );
xArrow->setMaterial( xMaterial );
QGLSceneNode* y = new QGLSceneNode( m_node );
y->addNode(cylinder);
q = QQuaternion::fromAxisAndAngle(1.0f, 0.0f, 0.0f, -90.0f);
matrix.rotate( q );
y->setLocalTransform( matrix );
QGLSceneNode* yArrow = new QGLSceneNode( m_node );
yArrow->addNode( arrow );
yArrow->setLocalTransform( matrix );
QGLMaterial* yMaterial = new QGLMaterial;
yMaterial->setDiffuseColor(Qt::green);
y->setMaterial( yMaterial );
QGLMaterial* yArrowMaterial = new QGLMaterial;
yArrowMaterial->setDiffuseColor( QColor( 0, 255, 0, 128 ) );
yArrow->setMaterial( yArrowMaterial );
QGLSceneNode* z = new QGLSceneNode( m_node );
z->addNode(cylinder);
QGLSceneNode* zArrow = new QGLSceneNode( m_node );
zArrow->addNode( arrow );
QGLMaterial* zMaterial = new QGLMaterial;
zMaterial->setDiffuseColor(Qt::blue);
z->setMaterial( zMaterial );
QGLMaterial* zArrowMaterial = new QGLMaterial;
zArrowMaterial->setDiffuseColor( QColor( 0, 0, 255, 128 ) );
zArrow->setMaterial( zArrowMaterial );
}
CylinderView::CylinderView(QWindow *parent)
: QGLView(parent)
{
QGLBuilder builder;
// Evil hack: it is not possible to just call glClearColor on any device
// but it is possible to have a huge, dark SkyBox. Without this hack the
// cylinder floats over a transparent background, displaying the contents
// of the last app
builder << QGL::Smooth << QGLCube(1000.0f);
// Add the cylinder
builder << QGL::Smooth << QGLCylinder(2.0, 1.5, 2.0, 36, 3, true, true);
QGLMaterial *matLid = new QGLMaterial;
matLid->setAmbientColor(Qt::gray);
matLid->setDiffuseColor(Qt::gray);
QUrl urlLid;
urlLid.setPath(QLatin1String(":/latte.png"));
urlLid.setScheme(QLatin1String("file"));
matLid->setTextureUrl(urlLid);
QGLMaterial *matSides = new QGLMaterial;
matSides->setColor(QColor(170, 202, 0));
QUrl urlSides;
urlSides.setPath(QLatin1String(":/cupTexture.png"));
urlSides.setScheme(QLatin1String("file"));
matSides->setTextureUrl(urlSides);
QGLSceneNode *root = builder.sceneNode();
QGLSceneNode *lid = root->findChild<QGLSceneNode *>("Cylinder Top");
int lidMat = root->palette()->addMaterial(matLid);
lid->setMaterialIndex(lidMat);
lid->setEffect(QGL::LitDecalTexture2D);
QGLSceneNode *sides = root->findChild<QGLSceneNode *>("Cylinder Sides");
int sideMat = root->palette()->addMaterial(matSides);
sides->setMaterialIndex(sideMat);
sides->setEffect(QGL::LitDecalTexture2D);
cylinder = builder.finalizedSceneNode();
QGLMaterial *mat = new QGLMaterial;
mat->setAmbientColor(Qt::gray);
mat->setDiffuseColor(Qt::gray);
cylinder->setMaterial(mat);
cylinder->setEffect(QGL::LitMaterial);
}
QGLMaterial *Bitmap3DRender::material(QColor color)
{
Q_D(Bitmap3DRender);
QGLMaterial *material = d->materials.material(color.name());
if (material == NULL)
{
material = new QGLMaterial;
material->setObjectName(color.name());
color.setAlpha(1);
material->setColor(color);
d->materials.addMaterial(material);
}
return material;
}
QDebug operator<<(QDebug dbg, const QGLMaterial &material)
{
dbg << &material <<
"-- Amb:" << material.ambientColor() <<
"-- Diff:" << material.diffuseColor() <<
"-- Spec:" << material.specularColor() <<
"-- Shin:" << material.shininess();
for (int i = 0; i < material.textureLayerCount(); ++i)
if (material.texture(i) != 0)
dbg << "\n -- Tex" << i << ":" << material.texture(i)
<< material.texture(i)->objectName();
dbg << "\n";
return dbg;
}
static QGLMaterial *qCreateFluid()
{
QImage image(QSize(128,128), QImage::Format_ARGB32);
QRgb col = qRgba(rval(), rval(), rval(), 196);
image.fill(col);
QPainter painter(&image);
QLinearGradient linearGrad(QPointF(56, 56), QPointF(72, 72));
linearGrad.setColorAt(0, col);
linearGrad.setColorAt(1, QColor(col).lighter());
linearGrad.setSpread(QGradient::ReflectSpread);
painter.fillRect(image.rect(), linearGrad);
painter.end();
QGLMaterial *mat = new QGLMaterial;
QColor white(Qt::white);
white.setAlpha(128);
mat->setAmbientColor(white);
mat->setDiffuseColor(white);
QGLTexture2D *tex = new QGLTexture2D(mat);
tex->setImage(image);
mat->setTexture(tex);
return mat;
}
/* Creates the scene of balls */
void ModelBall::createScene() {
qsrand(QDateTime::currentMSecsSinceEpoch());
QGLMaterial *material = new QGLMaterial();
material->setColor(Qt::blue);
material->setSpecularColor(QColor(SPECULAR_COLOR));
material->setAmbientColor(QColor(AMBIENT_COLOR));
material->setEmittedLight(QColor(EMITTED_LIGHT_COLOR));
material->setShininess(SHININESS);
for (int i = 0; i < ANIMATION_BALLS; i++) {
_nodes.append(createNode(material));
_phase[i] = 2 * M_PI / ANIMATION_BALLS * i - M_PI;
}
_mainNode = _nodes.first();
}
void loadProperty(const QString &property, QTextStream &value) {
if (property == "material") {
QGLMaterial *mat = new QGLMaterial();
QString name, file;
value >> name >> file;
if (file != "-") {
QGLTexture2D *tex = new QGLTexture2D();
tex->setImage(QImage(dataDir + file));
mat->setTexture(tex);
mat->setTextureCombineMode(QGLMaterial::Decal);
}
int r, g, b;
value >> r >> g >> b; if (r != -1) mat->setAmbientColor(QColor(r, g, b));
value >> r >> g >> b; if (r != -1) mat->setDiffuseColor(QColor(r, g, b));
value >> r >> g >> b; if (r != -1) mat->setSpecularColor(QColor(r, g, b));
qreal shin; value >> shin; mat->setShininess(shin);
palette.insert(name, mat);
} else if (property == "size") {
/*!
Initializes the Qt3D materials used in the application.
*/
void GameView::initializeMaterials()
{
m_MaterialCollection = new QGLMaterialCollection(this);
QGLTexture2D *lightTexture = new QGLTexture2D;
lightTexture->setImage(QImage(":/reflectionmap.png"));
QColor ambientColor = QColor(64, 64, 190);
QGLMaterial *material = new QGLMaterial;
material->setObjectName("PauseButtonMaterial");
QGLTexture2D *texture = new QGLTexture2D;
texture->setImage(QImage(":/pause_button.png"));
material->setTexture(texture);
m_MaterialCollection->addMaterial(material);
// Black hole material
material = new QGLMaterial;
material->setObjectName("BlackHoleMaterial");
texture = new QGLTexture2D;
texture->setImage(QImage(":/BlackHole.jpg"));
material->setTexture(texture);
texture = new QGLTexture2D;
texture->setImage(QImage(":/bh_sprial.png"));
material->setTexture(texture, 1);
material->setTextureCombineMode(QGLMaterial::Replace);
m_MaterialCollection->addMaterial(material);
// Black hole center material
material = new QGLMaterial;
material->setObjectName("BlackHoleFrontMaterial");
texture = new QGLTexture2D;
texture->setImage(QImage(":/bh_sprial.png"));
material->setTexture(texture);
material->setTexture(lightTexture, 1);
m_MaterialCollection->addMaterial(material);
// Platform material
material = new QGLMaterial;
material->setObjectName("PlatformMaterial");
texture = new QGLTexture2D;
texture->setImage(QImage(":/platformtex.png"));
material->setTexture(texture);
m_MaterialCollection->addMaterial(material);
// Blok material
material = new QGLMaterial;
material->setObjectName("BlokMaterial");
texture = new QGLTexture2D;
texture->setImage(QImage(":/SimpleBlock.png"));
material->setTexture(texture);
material->setTexture(lightTexture, 1);
material->setAmbientColor(ambientColor);
material->setShininess(0.2f);
m_MaterialCollection->addMaterial(material);
// Ball materials
material = new QGLMaterial;
material->setObjectName("BallMaterial1");
material->setAmbientColor(ambientColor);
material->setDiffuseColor(QColor(255, 255, 64));
material->setTexture(texture, 0);
material->setTexture(lightTexture, 1);
material->setShininess(1.0f);
material->setSpecularColor(material->diffuseColor());
m_MaterialCollection->addMaterial(material);
material = new QGLMaterial;
material->setObjectName("BallMaterial2");
material->setAmbientColor(ambientColor);
material->setDiffuseColor(QColor(255, 64, 64));
material->setTexture(texture, 0);
material->setTexture(lightTexture, 1);
material->setShininess(1.0f);
material->setSpecularColor(material->diffuseColor());
m_MaterialCollection->addMaterial(material);
material = new QGLMaterial;
material->setObjectName("BallMaterial3");
material->setDiffuseColor(QColor(64, 64, 255));
material->setAmbientColor(ambientColor);
material->setTexture(texture, 0);
material->setTexture(lightTexture, 1);
material->setShininess(1.0f);
material->setSpecularColor(material->diffuseColor());
m_MaterialCollection->addMaterial(material);
material = new QGLMaterial;
material->setObjectName("BallMaterial4");
material->setDiffuseColor(QColor(64, 255, 64));
material->setAmbientColor(ambientColor);
material->setTexture(texture, 0);
material->setTexture(lightTexture,1);
material->setShininess(1.0f);
material->setSpecularColor(material->diffuseColor());
m_MaterialCollection->addMaterial(material);
material = new QGLMaterial;
material->setObjectName("LightFlareMaterial");
texture = new QGLTexture2D;
texture->setImage(QImage(":/flare.png"));
material->setTexture(texture);
m_MaterialCollection->addMaterial(material);
material = new QGLMaterial;
material->setObjectName("FontMaterial");
texture = new QGLTexture2D;
texture->setImage(QImage(":/scorefont.png"));
material->setTexture(texture);
m_MaterialCollection->addMaterial(material);
}
void tst_QGLRender::sequence()
{
QSKIP("QWidget: Cannot create a QWidget when no GUI is being used");
QSharedPointer<QGLMaterialCollection> palette(new QGLMaterialCollection());
// create a yellow lit material
QGLMaterial *mat = new QGLMaterial;
mat->setAmbientColor(Qt::yellow);
int ix0 = palette->addMaterial(mat);
// create a blue lit material
mat = new QGLMaterial;
mat->setAmbientColor(Qt::blue);
int ix1 = palette->addMaterial(mat);
// create a grey textured material
int tx0;
{
QImage uv(1024, 1024, QImage::Format_ARGB32);
uv.fill(qRgba(196, 196, 196, 196));
mat = new QGLMaterial;
mat->setAmbientColor(Qt::gray);
QGLTexture2D *tex = new QGLTexture2D;
tex->setImage(uv);
mat->setTexture(tex);
tx0 = palette->addMaterial(mat);
}
QGLSceneNode *scene = new QGLSceneNode;
scene->setPalette(palette);
QGLSceneNode *node = 0;
QGLSceneNode *prim;
{
QGLBuilder builder(palette);
QVector3D a(-1.0f, -1.0f, 0.0f);
QVector3D b(1.0f, -1.0f, 0.0f);
QVector3D c(1.0f, 1.0f, 0.0f);
QGeometryData p;
p.appendVertex(a, b, c);
p.generateTextureCoordinates();
builder.addTriangles(p);
prim = builder.currentNode();
prim->setMaterialIndex(ix0);
builder.newSection();
QVector3D d(-1.2f, -1.2f, 0.0f);
QVector3D e(1.2f, -1.2f, 0.0f);
QVector3D f(1.2f, 1.2f, 0.0f);
QVector3D g(-1.2f, 1.2f, 0.0f);
QGeometryData q;
q.appendVertex(d, e, f, g);
q.generateTextureCoordinates();
builder.addQuads(q);
prim = builder.currentNode();
prim->setMaterialIndex(ix1);
node = builder.finalizedSceneNode();
}
scene->addNode(node);
QGLSceneNode *cl = prim->clone(scene);
cl->setMaterialIndex(tx0);
cl->setEffect(QGL::LitDecalTexture2D);
TestView widget(scene);
if (!widget.context()->isValid())
QSKIP("GL Implementation not valid");
TestPainter *ptr = new TestPainter(&widget);
widget.paintGL(ptr);
QList<int> starts = ptr->starts();
QList<int> counts = ptr->counts();
QCOMPARE(starts.at(0), 0);
QCOMPARE(counts.at(0), 3);
QCOMPARE(starts.at(1), 3);
QCOMPARE(counts.at(1), 6);
}