bool PxSingleActor::prepRenderImage( SceneState *state,
const U32 stateKey,
const U32 startZone,
const bool modifyBaseState )
{
if ( !mShapeInstance || !state->isObjectRendered(this) )
return false;
Point3F cameraOffset;
getTransform().getColumn(3,&cameraOffset);
cameraOffset -= state->getDiffuseCameraPosition();
F32 dist = cameraOffset.len();
if ( dist < 0.01f )
dist = 0.01f;
F32 invScale = (1.0f/getMax(getMax(getScale().x,getScale().y),getScale().z));
dist *= invScale;
S32 dl = mShapeInstance->setDetailFromDistance( state, dist );
if (dl<0)
return false;
renderObject( state );
return false;
}
void renderLayer ( BackGenEngine::BLayer *pc_layer ) {
BackGenEngine::BLayer::bobject_hash_t::ConstIterator it = pc_layer->constBegin();
while ( it != pc_layer->constEnd() ) {
renderObject ( ( *it ) );
++it;
}
}
//-------------------------------------------------------------------------------------------------------------------------------------------------------------------
GLvoid ChessGame::createGridList( GLvoid (*renderObject)(void))
{
if( gridList == 0)
{
gridList = glGenLists(1);
glNewList (gridList,GL_COMPILE_AND_EXECUTE);
for(GLfloat x = -20.0f ; x < 20.0f; x+= 2.5f)
{
for(GLfloat y = -20.0f; y < 20.0f; y +=2.50f)
{
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glTranslatef(x, y, 0.0f);
renderObject();
glPopMatrix();
}
}
glEndList();
}
else
{
glCallList( gridList );
}
}
//--Implementations
void render()
{
int counter;
//clear the screen
glClearColor(1.0, 1.0, 1.0, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//enable the shader program
glUseProgram(program);
glUniform1f(loc_lightType, lightTypeVal);
glUniform1f(loc_lightType2, lightTypeVal2);
for(counter = 0; counter < globalObjCount; counter++)
{
//matrix MVP for planet
mvp = projection * view * objectsDataList.getModelMatrix(counter);
// load each objects mvp
renderObject( mvp, counter );
}
score();
//Render Text
string playerOneStr = "Player One Score:" + numToStr(scoreOne);
string elapsedTime = "Elapsed Time:" + numToStr(elapsedDT());
glColor3d(0.0, 0.0, 0.0);
glMatrixMode(GL_PROJECTION);
//glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, w, 0, h);
glScalef(1, -1, 1);
glTranslatef(0, -h, 0);
//glMatrixMode(GL_MODELVIEW);
//glLoadIdentity();
renderBitmapString(30,40,(void *)GLUT_BITMAP_HELVETICA_18,playerOneStr);
glColor3d(0.0, 0.0, 0.0);
renderBitmapString(30,60,(void *)GLUT_BITMAP_HELVETICA_18,elapsedTime);
glPushMatrix();
//glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
//clean up
glDisableVertexAttribArray(loc_position);
glDisableVertexAttribArray(loc_uv);
glDisableVertexAttribArray(loc_normal);
//enable depth testing
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LESS);
//swap the buffers
glutSwapBuffers();
}
/**
* Draw the sprites on the screen
*/
void Game::renderGame() {
//Temporal variable
Camera _camera(WIDTH, HEIGHT, _screenType);
//Clear the color and depth buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//Bind the GLSL program. Only one code GLSL can be used at the same time
_colorProgram.use();
//For each one of the elements: Each object MUST BE RENDERED based on its position, rotation and scale data
for (int i = 0; i < _gameElements.getNumGameElements(); i++) {
renderObject(_gameElements.getGameElement(i));
}
for (int i = 0; i < NUMPARTICLES; i++) {
renderObject(_gameElements.getGameParticle(i));
}
//Unbind the program
_colorProgram.unuse();
//Swap the display buffers (displays what was just drawn)
_window.swapBuffer();
}
void CommentableObjectViewer::onViewObject()
{
shared_ptr<ObjectsIRevisionable> object = getObject();
if(object == nullptr)
return;
shared_ptr<XMLPortalExporter> exporter(OS_NEW XMLPortalExporter(getDocument()->create(object->getDescriptor()->getTypeName()), getPage(), XMLPortalExporter::emFull));
// Renderizza l'oggetto
renderObject(exporter, object);
// Renderizza i commenti sull'oggetto
renderPosts(exporter);
// Renderizza i tags dell'oggetto
renderTags(exporter);
}
void LogisticsMechIcon::render(long xOffset, long yOffset )
{
if ( bDisabled )
{
GUI_RECT tmprect = { outline.left() + xOffset, outline.top() + yOffset,
outline.right() + xOffset, outline.bottom() + yOffset };
drawRect( tmprect, 0xff000000 );
return;
}
if ( !pMech )
return;
long color = animations[outlineID].getCurrentColor(animations[outlineID].getState());
outline.setColor( color );
outline.render(xOffset, yOffset);
xOffset += outline.globalX();
yOffset += outline.globalY();
renderObject( icon, iconID, xOffset, yOffset );
renderObject( chassisName, chassisNameID, xOffset, yOffset );
renderObject( pilotName, pilotID, xOffset, yOffset );
renderObject( iconConnector, iconConnectorID, xOffset, yOffset );
renderObject( icon, iconID, xOffset, yOffset );
if ( pMech && pMech->getPilot() )
pilotIcon.render(xOffset, yOffset );
}
void IBLWidget::paintGL()
{
if(!isShowing())
return;
glcontext->makeCurrent(this);
glf->glClearColor( 0, 0, 0, 0 );
glf->glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
recreateFBO();
envRotMatrix = glm::rotate(glm::mat4(1.f), envPhi, glm::vec3(0, 1, 0));
envRotMatrix = glm::rotate(envRotMatrix, envTheta, glm::vec3(0, 1, 0));
envRotMatrixInverse = glm::inverse(envRotMatrix);
if( numSampleGroupsRendered < stepSize )
{
fbo->bind();
glf->glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
renderObject();
fbo->unbind();
///////////////////////////////////////
compResult();
// another sample group rendered!
numSampleGroupsRendered++;
if( renderWithIBL )
{
if( numSampleGroupsRendered < stepSize )
startTimer();
else
{
printf( "done!\n" );
stopTimer();
}
}
///////////////////////////////////////
}
// now draw the final result
drawResult();
glcontext->swapBuffers(this);
}
void main_display()
{
glClear(GL_COLOR_BUFFER_BIT);
glShadeModel(GL_FLAT);
//glEnable(GL_DEPTH_TEST);
texture();
glColor3f(1.0, 0.3, 0.2);
//glEnable(GL_TEXTURE_2D);
glPushMatrix();
//glScalef(0.001, 0.001, 0.001);
//glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
renderObject(&cylinder);
glColor3f(1.0, 0.6, 0.8);
renderPerVertexNormals(&cylinder);
glPopMatrix();
glutSwapBuffers();
}
static void
renderFrame(void)
{
struct Object *o;
if (currentFrame < 0) currentFrame = 0;
if (currentFrame >= numFrames) currentFrame = numFrames - 1;
if (currentFrame >= 0) {
o = &movie[frames[currentFrame]];
while (o->type != OBJ_FRAME) {
renderObject(o);
o++;
}
if (currentFrame != previousFrame) {
printf("%d: %s\n", currentFrame, o->u.frame.s);
previousFrame = currentFrame;
}
}
}
//Рекурсивный рендер объекта
void GlutViewer::renderObject(Object3D* object, Color color)
{
for (int i = 0; i < object->ChildrenCount(); i++)
{
BaseObject3D* curObject = object->GetChild(i);
if (curObject != NULL)
{
if (curObject->GetType() == BaseObject3D::TYPE_OBJECT)
renderObject(dynamic_cast<Object3D*>(curObject), color);
else
{
cv::Vec3f coord = curObject->GetCoord();
glColor3f(color.R, color.G, color.B);
float x = coord[0] / 5.0;
float y = coord[1] / 5.0;
float z = coord[2] / 5.0;
//std::cout << x << " " << y << " " << z << "\n";
glVertex3f(coord[0]/5.0, coord[1]/5.0, coord[2]/5.0);
}
}
}
}
void Level::renderBlock(int bx, int by, f32 xx, f32 yy, bool walls)
{
int offs = objs->blocks[bx][by].offs;
int count = objs->blocks[bx][by].count;
for(int i = 0; i < count; i++)
{
LevelObj& obj = objs->objs[offs+i];
if(walls)
{
if(obj.type != BEH_WALL) continue;
}
else
{
if(obj.type == BEH_WALL) continue;
}
renderObject(obj, xx, yy, sc);
}
}
pair<int, vector<double>> SyntheticTrack::poseFromSynth(
Pose prev_pose, const cv::Mat& gray_next) {
Mat rendered_image;
vector<float> z_buffer;
renderObject(prev_pose, rendered_image, z_buffer);
Mat rendered_gray;
cvtColor(rendered_image, rendered_gray, CV_BGR2GRAY);
vector<Point2f> prev_pts, next_pts;
trackCorners(rendered_gray, gray_next, prev_pts, next_pts);
vector<float> depth_pts;
depth_pts.reserve(prev_pts.size());
for (auto pt : prev_pts) {
int x = floor(pt.x);
int y = floor(pt.y);
float depth = z_buffer.at(x + y * img_w_);
depth_pts.push_back(depth);
}
vector<float> translation;
vector<float> rotation;
vector<int> outliers;
Eigen::VectorXf beta;
vector<double> std_beta(6, 0);
if (prev_pts.size() > 4) {
beta = getPoseFromFlowRobust(prev_pts, depth_pts, next_pts, nodal_x_,
nodal_y_, focal_x_, focal_y_, 10, translation,
rotation, outliers);
for (auto i = 0; i < 6; ++i) std_beta[i] = beta(i);
}
return pair<int, vector<double>>(prev_pts.size(), std_beta);
}
//--Implementations
void render()
{
//cout << "Makes it to Render!" << endl;
int counter;
//clear the screen
glClearColor(0.2, 0.2, 0.2, 1.0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
//enable the shader program
glUseProgram(program);
for(counter = 0; counter < globalObjCount; counter++)
{
//matrix MVP for planet
mvp = projection * view * objectsDataList.getModelMatrix(counter);
// load each objects mvp
renderObject( mvp, counter );
}
//swap the buffers
glutSwapBuffers();
}
//Функция рендера
void GlutViewer::renderScene()
{
if (cloud == NULL)
return;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glLoadIdentity();
glPushMatrix();
//Трансформации сцены
glRotated(rotX, 1, 0, 0);
glRotated(rotY, 0, 1, 0);
glRotated(rotZ, 0, 0, 1);
glTranslated(posX, posY, posZ);
glScaled(scale, scale, scale);
glBegin(GL_POINTS);
glVertex3f(0, 0, 0);
//Отрисовываем модель
Color color(0, 0, 0);
for (int i = 0; i < cloud->ChildrenCount(); i++)
{
BaseObject3D* object = cloud->GetChild(i);
if (object != NULL)
{
if (object->GetType() == BaseObject3D::TYPE_OBJECT)
{
color.R += 0.5;
if (color.R > 1)
{
color.R = 0;
color.B += 0.5;
}
if (color.G > 1)
{
color.G = 0;
color.B += 0.5;
}
if (color.B > 1)
color.B = 0;
renderObject(dynamic_cast<Object3D*>(object), color);
}
else if (object->GetType() == BaseObject3D::TYPE_POINT)
{
cv::Vec3f coord = object->GetCoord();
glVertex3f(coord[0]/5.0, coord[1]/5.0, coord[2]/5.0);
}
}
}
//glVertex3f(0.5, 0, 0);
//glVertex3f(0, 0.5, 0);
//glVertex3f(0, 0, 0.5);
glEnd();
glutSwapBuffers();
}
