void GLBox::initializeGL()
{
// Let OpenGL clear to black
qglClearColor( black );
glEnable(GL_DEPTH_TEST);
if ( sharedListUsers == 0 ) { // No shared list has been made yet
sharedDisplayList = makeObject(); // Make one
object = sharedDisplayList; // Use it
sharedListUsers++; // Keep reference count
qDebug( "GLBox %s created shared display list.", name() );
}
else { // There is a shared diplay list
if ( isSharing() ) { // Can we access it?
object = sharedDisplayList; // Yes, use it
sharedListUsers++; // Keep reference count
qDebug( "GLBox %s uses shared display list.", name() );
}
else {
localDisplayList = makeObject(); // No, roll our own
object = localDisplayList; // and use that
qDebug( "GLBox %s uses private display list.", name() );
}
}
}
void* CQLFactory::makeObject(CQLChainedIdentifier* obj, FactoryType target)
{
//printf("CQLFactory::makeObject(chainedidentifier)\n");
PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLChainedIdentifier");
void *cqlChainedIdentifier = NULL;
_CQLObjectPtr._ptr = new CQLValue(*obj);
_makeObjectValues.append(_CQLObjectPtr);
switch(target)
{
case Value:
cqlChainedIdentifier =
_makeObjectValues[_makeObjectValues.size()-1]._ptr;
break;
case ChainedIdentifier:
cqlChainedIdentifier = NULL;
break;
default:
cqlChainedIdentifier =
makeObject((CQLValue*)(_CQLObjectPtr._ptr), target);
break;
}
PEG_METHOD_EXIT();
return cqlChainedIdentifier;
}
void* CQLFactory::makeObject(CQLTerm* obj, FactoryType target)
{
//printf("CQLFactory::makeObject(term)\n");
PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLTerm");
void *cqlTerm = NULL;
_CQLObjectPtr._ptr = new CQLExpression(*obj);
_makeObjectExpressions.append(_CQLObjectPtr);
switch(target)
{
case Expression:
cqlTerm =
_makeObjectExpressions[_makeObjectExpressions.size()-1]._ptr;
break;
case Term:
cqlTerm = NULL;
break;
default:
cqlTerm =
makeObject((CQLExpression*)(_CQLObjectPtr._ptr), target);
break;
}
PEG_METHOD_EXIT();
return cqlTerm;
}
void* CQLFactory::makeObject(CQLExpression* obj, FactoryType target)
{
//printf("CQLFactory::makeObject(expression)\n");
PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLExpression");
void *cqlExpression = NULL;
_CQLObjectPtr._ptr = new CQLSimplePredicate(*obj);
_makeObjectSimplePredicates.append(_CQLObjectPtr);
switch(target)
{
case SimplePredicate:
cqlExpression =
_makeObjectSimplePredicates[
_makeObjectSimplePredicates.size()-1]._ptr;
break;
case Expression:
cqlExpression = NULL;
break;
default:
cqlExpression =
makeObject((CQLSimplePredicate*)(_CQLObjectPtr._ptr),
target);
break;
}
PEG_METHOD_EXIT();
return cqlExpression;
}
void GLWidget::updateSnap(char * snapName){
if(object != 0){
glDeleteLists(object, 1);
object = 0;
}
xRot = 0;
yRot = 0;
zRot = 0;
lookAt.x = 0.0;
lookAt.y = 0.0;
lookAt.z = NEAR;
isFocusChanged = false;
isCtrl = false;
isCenChanged = false;
lastFocus.x = curFocus.x = 0.0;
lastFocus.y = curFocus.y = 0.0;
lastFocus.z = curFocus.z = -10.0;
lastCen.x = curCen.x = BOXSIZE/2.0;
lastCen.y = curCen.y = BOXSIZE/2.0;
lastCen.z = curCen.z = BOXSIZE/2.0;
snap = new Snap;
snap->readSnap(snapName);
object = makeObject();
updateGL();
emit infoChanged();
delete snap;
}
void HIC::GLObject::paintGL()
{
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
//glMatrixMode(GL_PROJECTION);
//glLoadIdentity();
//glRotatef(m_rotX,1.0f,0.0f,0.0f);
//glRotatef(m_rotY,0.0f,1.0f,0.0f);
//glRotatef(m_rotZ,0.0f,0.0f,1.0f);
//glScalef(m_zoom,m_zoom,m_zoom);
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslatef(m_transX,m_transY,m_transZ);
glBegin(GL_LINES);
glColor3f ( 1.0f, 0.0f, 0.0f);
glVertex3f( 0.0f, 0.0f, 0.0f);
glVertex3f(30.0f, 0.0f, 0.0f);
glColor3f ( 0.0f, 1.0f, 0.0f);
glVertex3f( 0.0f, 0.0f, 0.0f);
glVertex3f( 0.0f,30.0f, 0.0f);
glColor3f ( 0.0f, 0.0f, 1.0f);
glVertex3f( 0.0f, 0.0f, 0.0f);
glVertex3f( 0.0f, 0.0f,30.0f);
glEnd();
makeObject();
glPopMatrix();
}
/// \brief Make this Element a Property with an ECMA Array as the value.
/// This is an array of a single AMF type. These are stored
/// the same as an object, but with a different type.
///
/// @param data A smart pointer to a vector of Elements to use as the vaule.
///
/// @return A reference to this Element.
Element &
Element::makeStrictArray(std::vector<std::shared_ptr<cygnal::Element> > &data)
{
// GNASH_REPORT_FUNCTION;
makeObject(data);
_type = Element::STRICT_ARRAY_AMF0;
return *this;
}
void OGLContext::initializeGL()
{
makeObject();
glEnable(GL_DEPTH_TEST);
// glEnable(GL_CULL_FACE);
glEnable(GL_TEXTURE_2D);
}
//! [6]
void GLWidget::initializeGL()
{
qglClearColor(trolltechPurple.dark());
object = makeObject();
glShadeModel(GL_FLAT);
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
}
/**
* Create room a room_string
*
* @param room A pointer to the room array to hold the objects
* @param room_string A string representation of the room
* @param cornerStone The coordinates of the first object of the new room
* @param moveNum The number of moves the payer has made
*
* @return None
*/
void addRoom(Object* (*room)[ROOM_HEIGHT][ROOM_WIDTH], const char room_string[ROOM_HEIGHT][ROOM_WIDTH], Coordinate cornerStone, int moveNum) {
for(int i=cornerStone.y; i<ROOM_HEIGHT; i++) {
for(int j=cornerStone.x; j<(cornerStone.x + ROOM_WIDTH); j++) {
switch(room_string[i%ROOM_HEIGHT][j%ROOM_WIDTH]) {
case FLOOR_SYM:
(*room)[i%ROOM_HEIGHT][j%ROOM_WIDTH] = makeObject(FLOOR_SYM, FLOOR_NUM, i, j, 0, 0, moveNum);
break;
case WALL_SYM:
(*room)[i%ROOM_HEIGHT][j%ROOM_WIDTH] = makeObject(WALL_SYM, WALL_NUM, i, j, 0, 0, moveNum);
break;
case PLAYER_SYM:
(*room)[i%ROOM_HEIGHT][j%ROOM_WIDTH] = makeObject(PLAYER_SYM, PLAYER_NUM, i, j, DIR_DOWN, 0, moveNum);
break;
case TREASURE_SYM:
(*room)[i%ROOM_HEIGHT][j%ROOM_WIDTH] = makeObject(TREASURE_SYM, TREASURE_NUM, i, j, 0, 0, moveNum);
break;
case BAT_SYM:
(*room)[i%ROOM_HEIGHT][j%ROOM_WIDTH] = makeObject(BAT_SYM, BAT_NUM, i, j, DIR_UP, DIR_LEFT, moveNum);
break;
case ZOMBIE_SYM:
(*room)[i%ROOM_HEIGHT][j%ROOM_WIDTH] = makeObject(ZOMBIE_SYM, ZOMBIE_NUM, i, j, DIR_DOWN, DIR_LEFT, moveNum);
break;
case EMPTY_SYM:
(*room)[i%ROOM_HEIGHT][j%ROOM_WIDTH] = makeObject(EMPTY_SYM, EMPTY_NUM, i, j, 0, 0, moveNum);
break;
default:
_terminate(INVALID_OBJ_SYMBOL);
}
}
}
}
/// \brief Make this Element a Property with an ECMA Array as the value.
///
/// @param name The name of the Property
///
/// @param data A smart pointer to a vector of Elements to use as the vaule.
///
/// @return A reference to this Element.
Element &
Element::makeECMAArray(const std::string &name, std::vector<std::shared_ptr<cygnal::Element> > &data)
{
// GNASH_REPORT_FUNCTION;
_type = Element::ECMA_ARRAY_AMF0;
makeObject(name, data);
_type = Element::ECMA_ARRAY_AMF0;
return *this;
}
// add base 4
void MenuBar::addBlueBaseCallback_real(Fl_Widget* w) {
base* newObj = dynamic_cast< base* >( makeObject( "base" ) );
// set the base
if (newObj)
newObj->setTeam( BASE_BLUE );
value(0);
}
/// \brief Make this Element as an Object data type.
///
/// @param name The name of this object. This is not the same as
/// the name of a property.
///
/// @return A reference to this Element.
Element &
Element::makeObject(const std::string &name)
{
// GNASH_REPORT_FUNCTION;
if (name.size()) {
setName(name);
}
return makeObject();
}
void GLTexobj::initializeGL()
{
// Set up the lights
GLfloat whiteDir[4] = {2.0, 2.0, 2.0, 1.0};
GLfloat whiteAmb[4] = {1.0, 1.0, 1.0, 1.0};
GLfloat lightPos[4] = {30.0, 30.0, 30.0, 1.0};
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glEnable(GL_DEPTH_TEST);
glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_FALSE);
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, whiteAmb);
glMaterialfv(GL_FRONT, GL_DIFFUSE, whiteDir);
glMaterialfv(GL_FRONT, GL_SPECULAR, whiteDir);
glMaterialf(GL_FRONT, GL_SHININESS, 20.0);
glLightfv(GL_LIGHT0, GL_DIFFUSE, whiteDir); // enable diffuse
glLightfv(GL_LIGHT0, GL_SPECULAR, whiteDir); // enable specular
glLightfv(GL_LIGHT0, GL_POSITION, lightPos);
// Set up the textures
QImage tex1, tex2, buf;
if ( !buf.load( "opengl/gllogo.bmp" ) ) { // Load first image from file
qWarning( "Could not read image file, using single-color instead." );
QImage dummy( 128, 128, 32 );
dummy.fill( Qt::green.rgb() );
buf = dummy;
}
tex1 = QGLWidget::convertToGLFormat( buf ); // flipped 32bit RGBA
if ( !buf.load( "opengl/qtlogo.bmp" ) ) { // Load first image from file
qWarning( "Could not read image file, using single-color instead." );
QImage dummy( 128, 128, 32 );
dummy.fill( Qt::red.rgb() );
buf = dummy;
}
tex2 = QGLWidget::convertToGLFormat( buf ); // flipped 32bit RGBA
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glEnable( GL_TEXTURE_2D );
// Set up various other stuff
glClearColor( 0.0, 0.0, 0.0, 0.0 ); // Let OpenGL clear to black
glEnable( GL_CULL_FACE ); // don't need Z testing for convex objects
glHint( GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST );
// Make the object display list
object = makeObject( tex1, tex2 ); // Generate an OpenGL display list
}
/// \brief Make this Element a Property with an Object as the value.
///
/// @param name The name of the Property
///
/// @param data A smart pointer to an Element to use as the value.
///
/// @return A reference to this Element.
Element &
Element::makeObject(const std::string &name, std::vector<std::shared_ptr<Element> > &data)
{
// GNASH_REPORT_FUNCTION;
_type = OBJECT_AMF0;
if (name.size()) {
setName(name);
}
return makeObject(data);
}
void GLWidget::openFile()
{
//QTextStream qsout(stdout, QIODevice::WriteOnly);
QString fileName =
QFileDialog::getOpenFileName(this,
tr("open file"), "C:/Users/Tree/Desktop/M",
tr("Allfile(*.*);;Plyfile(*.ply);;Objfile(*.obj)"));
makeObject(fileName);
}
void GLWidget::initializeGL()
{
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-.5, .5, .5, -.5, -1000, 1000);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glClearColor(1.0f, 1.0f, 1.0f, 1.0f);
makeObject();
}
void MyGLWidget::initializeGL()
{
makeObject();
loadTextures();
glEnable(GL_TEXTURE_2D); // Enable Texture Mapping ( NEW )
glShadeModel(GL_SMOOTH); // Enables Smooth Shading
glClearColor(0.0f, 0.0f, 0.0f, 0.5f); // Black Background
glClearDepth(1.0f); // Depth Buffer Setup
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
glDepthFunc(GL_LEQUAL); // The Type Of Depth Test To Do
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations
}
void GLWidget::initializeGL()
{
makeObject();
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
#ifndef QT_OPENGL_ES_2
glEnable(GL_TEXTURE_2D);
#endif
#ifdef QT_OPENGL_ES_2
#define PROGRAM_VERTEX_ATTRIBUTE 0
#define PROGRAM_TEXCOORD_ATTRIBUTE 1
QGLShader *vshader = new QGLShader(QGLShader::Vertex, this);
const char *vsrc =
"attribute highp vec4 vertex;\n"
"attribute mediump vec4 texCoord;\n"
"varying mediump vec4 texc;\n"
"uniform mediump mat4 matrix;\n"
"void main(void)\n"
"{\n"
" gl_Position = matrix * vertex;\n"
" texc = texCoord;\n"
"}\n";
vshader->compileSourceCode(vsrc);
QGLShader *fshader = new QGLShader(QGLShader::Fragment, this);
const char *fsrc =
"uniform sampler2D texture;\n"
"varying mediump vec4 texc;\n"
"void main(void)\n"
"{\n"
" gl_FragColor = texture2D(texture, texc.st);\n"
"}\n";
fshader->compileSourceCode(fsrc);
program = new QGLShaderProgram(this);
program->addShader(vshader);
program->addShader(fshader);
program->bindAttributeLocation("vertex", PROGRAM_VERTEX_ATTRIBUTE);
program->bindAttributeLocation("texCoord", PROGRAM_TEXCOORD_ATTRIBUTE);
program->link();
program->bind();
program->setUniformValue("texture", 0);
#endif
}
void GLBox::initializeGL()
{
glDisable(GL_DEPTH_TEST);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
// glEnable(GL_POINT_SMOOTH);
glPointSize(1);
// qglClearColor(black);
gl_grid = makeObject(GLOBJ_GRID);
gl_channels = glGenLists(DP_DEPTH*(MAX_CHANNELS+1));
glShadeModel(GL_SMOOTH/*GL_FLAT*/);
font.init();
}
void MyGLWidget::initializeGL()
{
makeObject();
loadTextures();
glEnable(GL_TEXTURE_2D); // Enable Texture Mapping
glShadeModel(GL_SMOOTH); // Enables Smooth Shading
glClearColor(0.0f, 0.0f, 0.0f, 0.5f); // Black Background
glClearDepth(1.0f); // Depth Buffer Setup
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
glDepthFunc(GL_LEQUAL); // The Type Of Depth Test To Do
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations
glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient); // Setup The Ambient Light
glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse);
glLightfv(GL_LIGHT1, GL_POSITION,LightPosition); // Position The Light
glEnable(GL_LIGHT1); // Enable Light One
}
DerpObject::Ref DerpVM::compileString(
const std::string &str,
DerpErrorState &errorState,
const std::string &fileName) {
DerpExecNode *node = derpParseText(
this, str, errorState, fileName);
if(!node) {
return DerpObject::Ref(NULL);
}
DerpObject::Ref functionObject = makeObject();
vector<string> *paramNames = new vector<string>;
functionObject->setFunction(node, paramNames);
return functionObject;
}
void MyGLWidget::initializeGL()
{
makeObject();
loadTextures();
glEnable(GL_TEXTURE_2D); // Enable Texture Mapping
glShadeModel(GL_SMOOTH); // Enables Smooth Shading
glClearColor(0.0f, 0.0f, 0.0f, 0.5f); // Black Background
glClearDepth(1.0f); // Depth Buffer Setup
glEnable(GL_DEPTH_TEST); // Enables Depth Testing
glDepthFunc(GL_LEQUAL); // The Type Of Depth Test To Do
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST); // Really Nice Perspective Calculations
glLightfv(GL_LIGHT1, GL_AMBIENT, LightAmbient); // Setup The Ambient Light
glLightfv(GL_LIGHT1, GL_DIFFUSE, LightDiffuse);
glLightfv(GL_LIGHT1, GL_POSITION,LightPosition); // Position The Light
glEnable(GL_LIGHT1); // Enable Light One
glColor4f(1.0f,1.0f,1.0f,0.5f); // Full Brightness, 50% Alpha ( NEW )
glBlendFunc(GL_SRC_ALPHA,GL_ONE); // Blending Function For Translucency Based On Source Alpha Value ( NEW )
}
void GLWidget::initializeGL()
{
LOG_DEBUG() << "Initializing GLWidget (example rendering)...";
//if (mContextLock.tryLock(1000)) // prevent access to opengl context while rendering
{
makeCurrent();
glClearColor( 0.5, 0.5, 0.5, 0.0 ); // Let OpenGL clear to black
exampleObject = makeObject(); // generate an OpenGL display list
glShadeModel( GL_SMOOTH ); // smooth shading
int error = glGetError();
if (error)
LOG_ERROR() << "Error initializing OpenGL: " << error;
//doneCurrent();
//mContextLock.unlock();
}
//else
//LOG_ERROR() << "Initializing GLWidget failed. Could not access GL-Context.";
}
void GLWidget::initializeGL()
{
initializeGLFunctions();
makeObject();
// opengl settings
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glEnable(GL_TEXTURE_2D);
// transform matrices
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(-1.0, +1.0, +1.0, -1.0, 4.0, 15.0);
glMatrixMode(GL_MODELVIEW);
// shaders
QGLShader *vshader = new QGLShader(QGLShader::Vertex, this);
vshader->compileSourceFile(":/glsl/passThru_vert.glsl");
QGLShader *fshader = new QGLShader(QGLShader::Fragment, this);
fshader->compileSourceFile(":/glsl/uvMap_frag.glsl");
m_uvMapProgram = new QGLShaderProgram(this);
m_uvMapProgram->addShader(vshader);
m_uvMapProgram->addShader(fshader);
m_uvMapProgram->link();
fshader = new QGLShader(QGLShader::Fragment, this);
fshader->compileSourceFile(":/glsl/transparencyGrid_frag.glsl");
m_gridProgram = new QGLShaderProgram(this);
m_gridProgram->addShader(vshader);
m_gridProgram->addShader(fshader);
m_gridProgram->link();
emit initialized();
}
void* CQLFactory::makeObject(CQLFunction* obj, FactoryType target)
{
//printf("CQLFactory::makeObject(function)\n");
PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLFunction");
void *cqlFunction = NULL;
_CQLObjectPtr._ptr = new CQLFactor(*obj);
_makeObjectFactors.append(_CQLObjectPtr);
switch(target)
{
case Factor:
cqlFunction =
_makeObjectFactors[_makeObjectFactors.size()-1]._ptr;
break;
default:
cqlFunction =
makeObject((CQLFactor*)(_CQLObjectPtr._ptr), target);
break;
}
PEG_METHOD_EXIT();
return cqlFunction;
}
/**
* Add the next room to the dungeon
*
* @param dungeon A pointer to the dungeon and game info
* @param dungeon_idx the location of the room in the dungeon
* @param last_move The last move made by the player
* @param moveNum The number of moves made by the player
*
* @return None
*/
void extendDungeon(Dungeon *dungeon, int dungeon_idx, char last_move, int moveNum) {
int room_idx=2;
Coordinate cornerStone;
Room* new_room=NULL;
Room* prev_room=NULL;
if(last_move == dungeon->moveTypes.left)
room_idx = 0;
else if(last_move == dungeon->moveTypes.right)
room_idx = 1;
else if(last_move == dungeon->moveTypes.jump)
room_idx = 0;
else if(last_move == dungeon->moveTypes.jumpleft)
room_idx = 1;
else if(last_move == dungeon->moveTypes.jumpright)
room_idx = 0;
else if(last_move == dungeon->moveTypes.wait) {
if(moveNum > SECRET_NUM)
room_idx = 2;
else
room_idx = 1;
}
cornerStone.y=0;
cornerStone.x= (dungeon_idx*ROOM_WIDTH);
if(!(new_room = malloc(sizeof(Room))))
_terminate(ALLOCATE_ERROR);
addRoom(&new_room->contents, room_string[room_idx], cornerStone, moveNum);
for(prev_room=dungeon->start; prev_room->next!=NULL; prev_room=prev_room->next);
prev_room->next = new_room;
// Open door
Object* door;
door = prev_room->contents[ROOM_HEIGHT-3][ROOM_WIDTH-1];
destroyObject(door);
prev_room->contents[ROOM_HEIGHT-3][ROOM_WIDTH-1] = makeObject(EMPTY_SYM, EMPTY_NUM, ROOM_HEIGHT-3, cornerStone.x-1, 0, 0, moveNum);
}
void* CQLFactory::makeObject(CQLFactor* obj, FactoryType target)
{
//printf("CQLFactory::makeObject(factor)\n");
PEG_METHOD_ENTER(TRC_CQL, "CQLFactory::makeObject,CQLFactor");
void *cqlFactor = NULL;
_CQLObjectPtr._ptr = new CQLTerm(*obj);
_makeObjectTerms.append(_CQLObjectPtr);
switch(target)
{
case Term:
cqlFactor = _makeObjectTerms[_makeObjectTerms.size()-1]._ptr;
break;
case Factor:
cqlFactor = NULL;
break;
default:
cqlFactor = makeObject((CQLTerm*)(_CQLObjectPtr._ptr), target);
break;
}
PEG_METHOD_EXIT();
return cqlFactor;
}
namespace scene
{
// Primitives
// Left Wall
const Triangle leftWallA{{0, 0, 0}, {0, 100, 0}, {0, 0, 150}};
const Triangle leftWallB{{0, 100, 150}, {0, 0, 150}, {0, 100, 0}};
// Right Wall
const Triangle rightWallA{{100, 0, 0}, {100, 0, 150}, {100, 100, 0}};
const Triangle rightWallB{{100, 100, 150}, {100, 100, 0}, {100, 0, 150}};
// Back wall
const Triangle backWallA{{0, 0, 0}, {100, 0, 0}, {100, 100, 0}};
const Triangle backWallB{{0, 0, 0}, {100, 100, 0}, {0, 100, 0}};
// Bottom Floor
const Triangle bottomWallA{{0, 0, 0}, {100, 0, 150}, {100, 0, 0}};
const Triangle bottomWallB{{0, 0, 0}, {0, 0, 150}, {100, 0, 150}};
// Top Ceiling
const Triangle topWallA{{0, 100, 0}, {100, 100, 0}, {0, 100, 150}};
const Triangle topWallB{{100, 100, 150}, {0, 100, 150}, {100, 100, 0}};
const Sphere leftSphere{16.5, glm::vec3 {27, 16.5, 47}};
const Sphere rightSphere{16.5, glm::vec3 {73, 16.5, 78}};
const Box box{glm::vec3{30,0,30}, glm::vec3{70,40,70}};
const MeshBoxes meshb = readObj(glm::vec3{50, 0, 50}, "../Beautiful Girl.obj");
const glm::vec3 light{50, 70, 81.6};
// Materials
const Diffuse white{{.75, .75, .75}};
const Diffuse red{{.75, .25, .25}};
const Diffuse blue{{.25, .25, .75}};
const Diffuse green{{.25, .75, .25}};
const Glass glass{{1, 1, 1}};
const Mirror mirror{{1, 1, 1}};
// Objects
// Note: this is a rather convoluted way of initialising a vector of unique_ptr ;)
const std::vector<std::unique_ptr<Object>> objects = [] (){
std::vector<std::unique_ptr<Object>> ret;
ret.push_back(makeObject(backWallA, white));
ret.push_back(makeObject(backWallB, white));
ret.push_back(makeObject(topWallA, white));
ret.push_back(makeObject(topWallB, white));
ret.push_back(makeObject(bottomWallA, white));
ret.push_back(makeObject(bottomWallB, white));
ret.push_back(makeObject(rightWallA, blue));
ret.push_back(makeObject(rightWallB, blue));
ret.push_back(makeObject(leftWallA, red));
ret.push_back(makeObject(leftWallB, red));
ret.push_back(makeObject(meshb, green));
//ret.push_back(makeObject(box, white));
ret.push_back(makeObject(leftSphere, mirror));
ret.push_back(makeObject(rightSphere, glass));
return ret;
}();
}
int main()
{
// Вызываю её так:
someFunc( makeObject() ); // сработает ли move-конструктор, ведь someFunc принимает const?
}
