void TileMap::render(const double cameraX_, const double cameraY_){
assert((this->tilesetSprites.size() > 0) && "No tilesets detected for the TileMap!");
const Tmx::Layer* currentLayer;
for(unsigned int i = 0; i < this->layers - 1; i++){
currentLayer = this->map->GetLayer(i);
if (i > this->tileMatrix[0][0].size()){
Log(ERROR) << "Invalid layer number for rendering a TileMap layer.";
continue;
}
if(currentLayer->GetName() == "Background02"){
renderLayer(cameraX_/20, cameraY_, i);
}
else if(currentLayer->GetName() == "Background01"){
renderLayer(cameraX_/10, cameraY_, i);
}
else if(currentLayer->GetName() == "Background00"){
renderLayer(cameraX_/1.6, cameraY_, i);
}
else{
renderLayer(cameraX_, cameraY_, i);
}
}
}
void ClientMap::render () const
{
ExecutionTime renderTime("ClientMapRender", 2000L);
const int x = _screenRumbleOffsetX + _x + _camera.getViewportX();
const int y = _screenRumbleOffsetY + _y + _camera.getViewportY();
const int scissorX = std::max(0, x);
const int scissorY = std::max(0, y);
const bool debug = Config.isDebug();
if (debug) {
_frontend->renderRect(scissorX, scissorY, getPixelWidth() * _zoom, getPixelHeight() * _zoom, colorRed);
} else {
_frontend->enableScissor(scissorX, scissorY, getPixelWidth() * _zoom, getPixelHeight() * _zoom);
}
renderLayer(x, y, LAYER_BACK);
renderLayer(x, y, LAYER_MIDDLE);
renderLayer(x, y, LAYER_FRONT);
if (_restartDue != 0) {
renderFadeOutOverlay();
}
Config.setDebugRendererData(x, y, getWidth(), getHeight(), _scale * _zoom);
Config.getDebugRenderer().render();
renderParticles(x, y);
if (!debug) {
_frontend->disableScissor();
}
}
void Renderer<Image>::render(const Map& map,Image& image)
{
timer clock;
//////////////////////////////////////////////////////
const Envelope<double>& extent=map.getCurrentExtent();
std::cout<<"BBOX:"<<extent<<"\n";
double scale=map.scale();
std::cout<<" scale="<<scale<<"\n";
unsigned width=map.getWidth();
unsigned height=map.getHeight();
CoordTransform t(width,height,extent);
const Color& background=map.getBackground();
image.setBackground(background);
for (size_t n=0;n<map.layerCount();++n)
{
const Layer& l=map.getLayer(n);
if (l.isVisible(scale))
{
//TODO make datasource to return its extent!!!
renderLayer(l,t,extent,image);
}
}
clock.stop();
}
void renderTransparentlLayers( ) {
BoxE::Core::BHash< BoxE::Core::BAsciiString, BackGenEngine::BLayer * >::ConstIterator it = TransparentLayersHash.constBegin();
while ( it != TransparentLayersHash.constEnd() ) {
renderLayer ( ( *it ) );
++it;
}
}
void Window::redraw( Canvas *canvas, const Rect &r ) {
std::vector<Rect> rects;
rects.push_back( r );
Surface *s = lockLayer( canvas );
if (s) {
renderLayer( s, rects );
unlockLayer( s );
}
}
void renderGUILayers( ) {
getScene()->getRenderer()->pushMatrix ( BOpenGLRenderer::MT_PROJECTION );
getScene()->getRenderer()->setMatrix ( BOpenGLRenderer::MT_PROJECTION, OrthoMatrix );
BoxE::Core::BHash< BoxE::Core::BAsciiString, BackGenEngine::BLayer * >::ConstIterator it = GUILayersHash.constBegin();
while ( it != GUILayersHash.constEnd() ) {
renderLayer ( ( *it ) );
++it;
}
getScene()->getRenderer()->popMatrix ( BOpenGLRenderer::MT_PROJECTION );
}
void CanvasGL::render(const Image* image, LayerType layerType, size_t idx) {
image_ = image;
layerType_ = layerType;
pickingContainer_->setPickingSource(image_);
if (image_) {
imageGL_ = image_->getRepresentation<ImageGL>();
if (imageGL_ && imageGL_->getLayerGL(layerType_, idx)) {
checkChannels(imageGL_->getLayerGL(layerType_, idx)->getDataFormat()->getComponents());
} else {
checkChannels(image_->getDataFormat()->getComponents());
}
renderLayer(idx);
// Faster async download of textures sampled on interaction
if (imageGL_->getDepthLayerGL())
imageGL_->getDepthLayerGL()->getTexture()->downloadToPBO();
if (pickingContainer_->pickingEnabled() && imageGL_->getPickingLayerGL())
imageGL_->getPickingLayerGL()->getTexture()->downloadToPBO();
} else {
imageGL_ = nullptr;
renderNoise();
}
}
void CanvasGL::update() {
renderLayer(previousRenderedLayerIdx_);
}
void WireExport::Export(string folder, string fileName)
{
MStatus stat;
mFolder = folder;
mFileName = fileName;
mSaver.SetFolder(mFolder);
MItDependencyNodes itRenderLayers(MFn::kRenderLayer,&stat);
err_code(stat);
MFnRenderLayer wireLayer;
while (!itRenderLayers.isDone())
{
MFnRenderLayer renderLayer( itRenderLayers.item() );
if (renderLayer.name() == "wire")
{
stat = wireLayer.setObject( renderLayer.object() );
err_code(stat);
break;
}
stat = itRenderLayers.next();
err_code(stat);
}
MItDependencyNodes itDepCurve(MFn::kNurbsCurve,&stat);
err_code(stat);
vector<Wire> wires;
while (!itDepCurve.isDone())
{
MObject obj = itDepCurve.item();
MFnNurbsCurve wire(obj, &stat);
err_code(stat);
bool objInLayer = wireLayer.inLayer(obj, &stat);
//err_code(stat);
if (!objInLayer)
{
stat = itDepCurve.next();
err_code(stat);
continue;
}
MString cmd = MString("reference -q -f ") + wire.name();
MString file_id;
stat = MGlobal::executeCommand( cmd, file_id );
if( stat == MS::kSuccess )
{
itDepCurve.next();
continue;
}
MObject parentObj = wire.parent(0, &stat);
err_code(stat);
Wire newWire;
newWire.name = wire.name().asChar();
MPointArray points;
stat = wire.getCVs(points);
err_code(stat);
int numOfPoints = points.length();
for (int n = 0; n < numOfPoints ; n++)
{
MPoint point = points[n];
WirePoint wirePoint;
wirePoint.x = (float)point.x;
wirePoint.z = (float)point.z;
double param;
stat = wire.getParamAtPoint( point, param );
err_code(stat);
MVector tangent = wire.tangent( param , MSpace::kObject, &stat);
err_code(stat);
tangent.normalize();
wirePoint.tx = (float)tangent.x;
wirePoint.tz = (float)tangent.z;
newWire.wirePoints.push_back(wirePoint);
}
wires.push_back(newWire);
stat = itDepCurve.next();
err_code(stat);
}
WriteWires(wires);
}
void RenderEngine::renderLayer(
const Layer* layer,
Image *image,
int source_x, int source_y,
FrameNumber frame, Zoom zoom,
void (*zoomed_func)(Image*, const Image*, const Palette*, int, int, int, int, Zoom),
bool render_background,
bool render_transparent,
int blend_mode)
{
// we can't read from this layer
if (!layer->isVisible())
return;
switch (layer->type()) {
case ObjectType::LayerImage: {
if ((!render_background && layer->isBackground()) ||
(!render_transparent && !layer->isBackground()))
break;
const Cel* cel = static_cast<const LayerImage*>(layer)->getCel(frame);
if (cel != NULL) {
Image* src_image;
// Is the 'preview_image' set to be used with this layer?
if ((selected_layer == layer) &&
(selected_frame == frame) &&
(preview_image != NULL)) {
src_image = preview_image;
}
// If not, we use the original cel-image from the images' stock
else {
src_image = cel->image();
}
if (src_image) {
int t, output_opacity;
output_opacity = MID(0, cel->opacity(), 255);
output_opacity = INT_MULT(output_opacity, global_opacity, t);
ASSERT(src_image->maskColor() == m_sprite->transparentColor());
(*zoomed_func)(image, src_image, m_sprite->getPalette(frame),
zoom.apply(cel->x()) - source_x,
zoom.apply(cel->y()) - source_y,
output_opacity,
(blend_mode < 0 ?
static_cast<const LayerImage*>(layer)->getBlendMode():
blend_mode),
zoom);
}
}
break;
}
case ObjectType::LayerFolder: {
LayerConstIterator it = static_cast<const LayerFolder*>(layer)->getLayerBegin();
LayerConstIterator end = static_cast<const LayerFolder*>(layer)->getLayerEnd();
for (; it != end; ++it) {
renderLayer(*it, image,
source_x, source_y,
frame, zoom, zoomed_func,
render_background,
render_transparent,
blend_mode);
}
break;
}
}
// Draw extras
if (m_document->getExtraCel() &&
layer == m_currentLayer &&
frame == m_currentFrame) {
Cel* extraCel = m_document->getExtraCel();
if (extraCel->opacity() > 0) {
Image* extraImage = m_document->getExtraCelImage();
(*zoomed_func)(image, extraImage, m_sprite->getPalette(frame),
zoom.apply(extraCel->x()) - source_x,
zoom.apply(extraCel->y()) - source_y,
extraCel->opacity(),
m_document->getExtraCelBlendMode(), zoom);
}
}
}
/**
Draws the @a frame of animation of the specified @a sprite
in a new image and return it.
Positions source_x, source_y, width and height must have the
zoom applied (zoom.apply(sorce_x), zoom.apply(source_y), zoom.apply(width), etc.)
*/
Image* RenderEngine::renderSprite(int source_x, int source_y,
int width, int height,
FrameNumber frame, Zoom zoom,
bool draw_tiled_bg,
bool enable_onionskin,
ImageBufferPtr& buffer)
{
void (*zoomed_func)(Image*, const Image*, const Palette*, int, int, int, int, Zoom);
const LayerImage* background = m_sprite->backgroundLayer();
bool need_checked_bg = (background != NULL ? !background->isVisible(): true);
uint32_t bg_color = 0;
Image *image;
switch (m_sprite->pixelFormat()) {
case IMAGE_RGB:
zoomed_func = merge_zoomed_image<RgbTraits, RgbTraits>;
break;
case IMAGE_GRAYSCALE:
zoomed_func = merge_zoomed_image<RgbTraits, GrayscaleTraits>;
break;
case IMAGE_INDEXED:
zoomed_func = merge_zoomed_image<RgbTraits, IndexedTraits>;
if (!need_checked_bg)
bg_color = m_sprite->getPalette(frame)->getEntry(m_sprite->transparentColor());
break;
default:
return NULL;
}
// Create a temporary RGB bitmap to draw all to it
image = Image::create(IMAGE_RGB, width, height, buffer);
if (!image)
return NULL;
// Draw checked background
if (need_checked_bg && draw_tiled_bg)
renderCheckedBackground(image, source_x, source_y, zoom);
else
clear_image(image, bg_color);
// Draw the current frame.
global_opacity = 255;
renderLayer(m_sprite->folder(), image,
source_x, source_y, frame, zoom, zoomed_func, true, true, -1);
// Onion-skin feature: Draw previous/next frames with different
// opacity (<255) (it is the onion-skinning)
IDocumentSettings* docSettings = UIContext::instance()
->settings()->getDocumentSettings(m_document);
if (enable_onionskin & docSettings->getUseOnionskin()) {
int prevs = docSettings->getOnionskinPrevFrames();
int nexts = docSettings->getOnionskinNextFrames();
int opacity_base = docSettings->getOnionskinOpacityBase();
int opacity_step = docSettings->getOnionskinOpacityStep();
for (FrameNumber f=frame.previous(prevs); f <= frame.next(nexts); ++f) {
if (f == frame || f < 0 || f > m_sprite->lastFrame())
continue;
else if (f < frame)
global_opacity = opacity_base - opacity_step * ((frame - f)-1);
else
global_opacity = opacity_base - opacity_step * ((f - frame)-1);
if (global_opacity > 0) {
global_opacity = MID(0, global_opacity, 255);
int blend_mode = -1;
if (docSettings->getOnionskinType() == IDocumentSettings::Onionskin_Merge)
blend_mode = BLEND_MODE_NORMAL;
else if (docSettings->getOnionskinType() == IDocumentSettings::Onionskin_RedBlueTint)
blend_mode = (f < frame ? BLEND_MODE_RED_TINT: BLEND_MODE_BLUE_TINT);
renderLayer(m_sprite->folder(), image,
source_x, source_y, f, zoom, zoomed_func,
true, true, blend_mode);
}
}
}
return image;
}
//===========================================================================
void cCamera::renderView(const int a_windowWidth,
const int a_windowHeight)
{
//-----------------------------------------------------------------------
// (1) COMPUTE SHADOW MAPS
//-----------------------------------------------------------------------
// initialize a temporary variable that will inform us if shadow casting is used
// by our application and also supported by the hardware.
bool useShadowCasting = false;
list<cShadowMap*> shadowMaps;
shadowMaps.clear();
// shadow casting has been requested, we will first need to verify if the hardware
// can support it
if (m_useShadowCasting)
{
// we verify if shadow casting is supported by hardware
if (isShadowCastingSupported())
{
// we check every light source. if it is a spot light we verify if shadow casting is enabled
for (unsigned int i=0; i<m_parentWorld->m_lights.size(); i++)
{
cSpotLight* light = dynamic_cast<cSpotLight*>(m_parentWorld->getLightSource(i));
if (light != NULL)
{
if (light->getShadowMapEnabled())
{
// update shadow map
light->updateShadowMap();
// add shadowmap to list
shadowMaps.push_back(light->m_shadowMap);
// shadow mapping is used by at least one light source!
useShadowCasting = true;
}
}
}
}
}
//-----------------------------------------------------------------------
// (2) INITIALIZE CURRENT VIEWPORT
//-----------------------------------------------------------------------
// check window size
if (a_windowHeight == 0) { return; }
// store most recent size of display
m_lastDisplayWidth = a_windowWidth;
m_lastDisplayHeight = a_windowHeight;
// setup viewport
glViewport(0, 0, a_windowWidth, a_windowHeight);
// compute aspect ratio
double glAspect = ((double)a_windowWidth / (double)a_windowHeight);
// compute global pose
computeGlobalPositionsFromRoot(true);
// set background color
glClearColor(m_parentWorld->getBackgroundColor().getR(),
m_parentWorld->getBackgroundColor().getG(),
m_parentWorld->getBackgroundColor().getB(),
1.0);
//-----------------------------------------------------------------------
// (3) VERIFY IF STEREO DISPLAY IS ENABLED
//-----------------------------------------------------------------------
GLboolean stereo = false;
unsigned int numStereoPass = 1;
if (m_useStereo)
{
// verify if stereo is available by the graphics hardware and camera is of perspective model
glGetBooleanv(GL_STEREO, &stereo);
if (stereo && m_perspectiveMode)
{
// stereo is available - we shall perform 2 rendering passes for LEFT and RIGHT eye.
numStereoPass = 2;
}
else
{
stereo = false;
}
}
//-----------------------------------------------------------------------
// (4) RENDER THE ENTIRE SCENE
//-----------------------------------------------------------------------
for (unsigned int i=0; i<numStereoPass; i++)
{
//-------------------------------------------------------------------
// (4.1) SELECTING THE DISPLAY BUFFER (MONO / STEREO)
//-------------------------------------------------------------------
if (stereo)
{
if (i == 0)
{
glDrawBuffer(GL_BACK_LEFT);
}
else
{
glDrawBuffer(GL_BACK_RIGHT);
}
}
else
{
glDrawBuffer(GL_BACK);
}
//-------------------------------------------------------------------
// (4.2) CLEAR CURRENT BUFFER
//-------------------------------------------------------------------
// clear the color and depth buffers
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glShadeModel(GL_SMOOTH);
//-------------------------------------------------------------------
// (4.3) RENDER BACK PLANE
//-------------------------------------------------------------------
// render the 2D backlayer
// it will set up its own projection matrix
if (m_backLayer->getNumChildren())
{
renderLayer(m_backLayer,
a_windowWidth,
a_windowHeight);
}
// clear depth buffer
glClear(GL_DEPTH_BUFFER_BIT);
//-------------------------------------------------------------------
// (4.4a) SETUP CAMERA (MONO RENDERING)
//-------------------------------------------------------------------
if (!stereo)
{
// init projection matrix
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
// create projection matrix depending of camera mode
if (m_perspectiveMode)
{
// setup perspective camera
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(
m_fieldViewAngle, // Field of View angle.
glAspect, // Aspect ratio of viewing volume.
m_distanceNear, // Distance to Near clipping plane.
m_distanceFar); // Distance to Far clipping plane.
}
else
{
// setup orthographic camera
double left = -m_orthographicWidth / 2.0;
double right = -left;
double bottom = left / glAspect;
double top = -bottom;
glOrtho(left, // Left vertical clipping plane.
right, // Right vertical clipping plane.
bottom, // Bottom vertical clipping plane.
top, // Top vertical clipping plane.
m_distanceNear, // Distance to Near clipping plane.
m_distanceFar // Distance to Far clipping plane.
);
}
// setup cameta position
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// compute camera location
cVector3d lookAt = m_globalRot.getCol0();
cVector3d lookAtPos;
m_globalPos.subr(lookAt, lookAtPos);
cVector3d up = m_globalRot.getCol2();
// setup modelview matrix
gluLookAt( m_globalPos(0) , m_globalPos(1) , m_globalPos(2) ,
lookAtPos(0) , lookAtPos(1) , lookAtPos(2) ,
up(0) , up(1) , up(2) );
}
//-------------------------------------------------------------------
// (4.4b) SETUP CAMERA (STEREO RENDERING)
//-------------------------------------------------------------------
else
{
//-----------------------------------------------------------------
// Based on Paul Bourke's stereo rendering tutorial:
// http://local.wasp.uwa.edu.au/~pbourke/miscellaneous/stereographics/stereorender/
//-----------------------------------------------------------------
double radians = ((C_PI / 180.0) * m_fieldViewAngle / 2.0f);
double wd2 = m_distanceNear * tan(radians);
double ndfl = m_distanceNear / m_stereoFocalLength;
// compute the look, up, and cross vectors
cVector3d lookv = m_globalRot.getCol0();
lookv.mul(-1.0);
cVector3d upv = m_globalRot.getCol2();
cVector3d offsetv = cCross(lookv,upv);
offsetv.mul(m_stereoEyeSeparation / 2.0);
if (i == 0) offsetv.mul(-1.0);
// decide whether to offset left or right
double stereo_multiplier = (i == 0) ? 1.0f : -1.0f; // (i == 0) correspond to LEFT IMAGE, (i == 1) correspond to RIGHT IMAGE
double left = -1.0 * glAspect * wd2 + stereo_multiplier * 0.5 * m_stereoEyeSeparation * ndfl;
double right = glAspect * wd2 + stereo_multiplier * 0.5 * m_stereoEyeSeparation * ndfl;
double top = wd2;
double bottom = -1.0 * wd2;
// setup projection matrix
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glFrustum(left,right,bottom,top,m_distanceNear,m_distanceFar);
// initialize modelview matrix
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// compute the offset we should apply to the current camera position
cVector3d pos = cAdd(m_globalPos,offsetv);
// compute the shifted camera position
cVector3d lookAtPos;
pos.addr(lookv, lookAtPos);
// setup modelview matrix
gluLookAt(pos(0) , pos(1) , pos(2) ,
lookAtPos(0) , lookAtPos(1) , lookAtPos(2) ,
upv(0) , upv(1) , upv(2)
);
}
// Backup the view and projection matrix for future reference
glGetDoublev(GL_PROJECTION_MATRIX,m_projectionMatrix.getData());
glGetDoublev(GL_MODELVIEW_MATRIX, m_modelviewMatrix.getData());
//-------------------------------------------------------------------
// (4.5) RENDER THE 3D WORLD
//-------------------------------------------------------------------
// Set up reasonable default OpenGL state
glEnable(GL_LIGHTING);
glDisable(GL_BLEND);
glDepthMask(GL_TRUE);
glEnable(GL_DEPTH_TEST);
glDepthFunc(GL_LEQUAL);
// rendering options
cRenderOptions options;
// optionally perform multiple rendering passes for transparency
if (m_useMultipassTransparency)
{
////////////////////////////////////////////////////////////////////
// MULTI PASS - USING SHADOW CASTING
////////////////////////////////////////////////////////////////////
if (useShadowCasting)
{
// setup rendering options
options.m_camera = this;
options.m_single_pass_only = false;
options.m_render_opaque_objects_only = true;
options.m_render_transparent_front_faces_only = false;
options.m_render_transparent_back_faces_only = false;
options.m_enable_lighting = true;
options.m_render_materials = true;
options.m_render_textures = true;
options.m_creating_shadow_map = false;
options.m_rendering_shadow = true;
options.m_shadow_light_level = 1.0 - m_parentWorld->getShadowIntensity();
options.m_storeObjectPositions = false;
options.m_resetDisplay = m_resetDisplay;
// render 1st pass (opaque objects - shadowed regions)
m_parentWorld->renderSceneGraph(options);
// setup rendering options
options.m_rendering_shadow = false;
options.m_shadow_light_level = 1.0;
// render 2nd pass (opaque objects - non shadowed regions)
list<cShadowMap*>::iterator i;
for(i = shadowMaps.begin(); i !=shadowMaps.end(); ++i)
{
cShadowMap *shadowMap = *i;
shadowMap->render(options);
glEnable(GL_POLYGON_OFFSET_FILL);
m_parentWorld->renderSceneGraph(options);
glDisable(GL_POLYGON_OFFSET_FILL);
// restore states
glActiveTexture(GL_TEXTURE0_ARB);
glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glDisable(GL_TEXTURE_GEN_R);
glDisable(GL_TEXTURE_GEN_Q);
glDisable(GL_ALPHA_TEST);
}
// setup rendering options
options.m_render_opaque_objects_only = false;
options.m_render_transparent_back_faces_only = true;
// render 3rd pass (transparent objects - back faces only)
m_parentWorld->renderSceneGraph(options);
// modify rendering options for third pass
options.m_render_transparent_back_faces_only = false;
options.m_render_transparent_front_faces_only = true;
// render 4th pass (transparent objects - back faces only)
m_parentWorld->renderSceneGraph(options);
}
////////////////////////////////////////////////////////////////////
// MULTI PASS - WITHOUT SHADOWS
////////////////////////////////////////////////////////////////////
else
{
// setup rendering options for first pass
options.m_camera = this;
options.m_single_pass_only = false;
options.m_render_opaque_objects_only = true;
options.m_render_transparent_front_faces_only = false;
options.m_render_transparent_back_faces_only = false;
options.m_enable_lighting = true;
options.m_render_materials = true;
options.m_render_textures = true;
options.m_creating_shadow_map = false;
options.m_rendering_shadow = false;
options.m_shadow_light_level = 1.0;
options.m_storeObjectPositions = true;
options.m_resetDisplay = m_resetDisplay;
// render 1st pass (opaque objects - all faces)
m_parentWorld->renderSceneGraph(options);
// modify rendering options
options.m_render_opaque_objects_only = false;
options.m_render_transparent_back_faces_only = true;
options.m_storeObjectPositions = false;
// render 2nd pass (transparent objects - back faces only)
m_parentWorld->renderSceneGraph(options);
// modify rendering options
options.m_render_transparent_back_faces_only = false;
options.m_render_transparent_front_faces_only = true;
// render 3rd pass (transparent objects - front faces only)
m_parentWorld->renderSceneGraph(options);
}
}
else
{
////////////////////////////////////////////////////////////////////
// SINGLE PASS - USING SHADOW CASTING
////////////////////////////////////////////////////////////////////
if (useShadowCasting)
{
// setup rendering options for single pass
options.m_camera = this;
options.m_single_pass_only = true;
options.m_render_opaque_objects_only = false;
options.m_render_transparent_front_faces_only = false;
options.m_render_transparent_back_faces_only = false;
options.m_enable_lighting = true;
options.m_render_materials = true;
options.m_render_textures = true;
options.m_creating_shadow_map = false;
options.m_rendering_shadow = true;
options.m_shadow_light_level = 1.0 - m_parentWorld->getShadowIntensity();
options.m_storeObjectPositions = false;
options.m_resetDisplay = m_resetDisplay;
// render 1st pass (opaque objects - all faces - shadowed regions)
m_parentWorld->renderSceneGraph(options);
// setup rendering options
options.m_rendering_shadow = false;
options.m_shadow_light_level = 1.0;
// render 2nd pass (opaque objects - all faces - non shadowed regions)
list<cShadowMap*>::iterator i;
for(i = shadowMaps.begin(); i !=shadowMaps.end(); ++i)
{
cShadowMap *shadowMap = *i;
shadowMap->render(options);
glEnable(GL_POLYGON_OFFSET_FILL);
m_parentWorld->renderSceneGraph(options);
glDisable(GL_POLYGON_OFFSET_FILL);
// restore states
glActiveTexture(GL_TEXTURE0_ARB);
glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glDisable(GL_TEXTURE_GEN_R);
glDisable(GL_TEXTURE_GEN_Q);
glDisable(GL_ALPHA_TEST);
}
// restore states
glActiveTexture(GL_TEXTURE0_ARB);
glDisable(GL_TEXTURE_2D);
glDisable(GL_TEXTURE_GEN_S);
glDisable(GL_TEXTURE_GEN_T);
glDisable(GL_TEXTURE_GEN_R);
glDisable(GL_TEXTURE_GEN_Q);
glDisable(GL_ALPHA_TEST);
}
////////////////////////////////////////////////////////////////////
// SINGLE PASS - WITHOUT SHADOWS
////////////////////////////////////////////////////////////////////
else
{
// setup rendering options for single pass
options.m_camera = this;
options.m_single_pass_only = true;
options.m_render_opaque_objects_only = false;
options.m_render_transparent_front_faces_only = false;
options.m_render_transparent_back_faces_only = false;
options.m_enable_lighting = true;
options.m_render_materials = true;
options.m_render_textures = true;
options.m_creating_shadow_map = false;
options.m_rendering_shadow = false;
options.m_shadow_light_level = 1.0;
options.m_storeObjectPositions = true;
options.m_resetDisplay = m_resetDisplay;
// render single pass (all objects)
m_parentWorld->renderSceneGraph(options);
}
}
//-------------------------------------------------------------------
// (4.6) RENDER FRONT PLANE
//-------------------------------------------------------------------
// clear depth buffer
glClear(GL_DEPTH_BUFFER_BIT);
// render the 'front' 2d object layer; it will set up its own
// projection matrix
if (m_frontLayer->getNumChildren() > 0)
{
renderLayer(m_frontLayer,
a_windowWidth,
a_windowHeight);
}
// if requested, display reset has now been completed
m_resetDisplay = false;
}
}
