chromium/third_party/angle/third_party/glmark2/src/src/scene-shadow.cpp

//
// Copyright © 2012 Linaro Limited
//
// This file is part of the glmark2 OpenGL (ES) 2.0 benchmark.
//
// glmark2 is free software: you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the Free Software
// Foundation, either version 3 of the License, or (at your option) any later
// version.
//
// glmark2 is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
// FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
// details.
//
// You should have received a copy of the GNU General Public License along with
// glmark2.  If not, see <http://www.gnu.org/licenses/>.
//
// Authors:
//  Jesse Barker
//
#include "scene.h"
#include "model.h"
#include "options.h"
#include "util.h"
#include "log.h"
#include "shader-source.h"
#include "stack.h"

string;
vector;
map;
Stack4;
mat4;
vec4;
vec3;
vec2;

static const vec4 lightPosition(0.0f, 3.0f, 2.0f, 1.0f);

//
// To create a shadow map, we need a framebuffer object set up for a 
// depth-only pass.  The render target can then be bound as a texture,
// and the depth values sampled from that texture can be used in the
// distance-from-light computations when rendering the shadow on the
// ground below the rendered object.
//
class DepthRenderTarget
{ … };

bool
DepthRenderTarget::setup(unsigned int canvas_fbo, unsigned int width, unsigned int height)
{ … }

void
DepthRenderTarget::teardown()
{ … }

void
DepthRenderTarget::enable(const mat4& mvp)
{ … }

void DepthRenderTarget::disable()
{ … }

//
// The actual shadow pass is really just a quad projected into the scene
// with the horse's shadow cast upon it.  In the vertex stage, we compute
// a texture coordinate for the depth texture look-up by transforming the
// current vertex position using a matrix describing the light's view point.
// In the fragment stage, that coordinate is perspective corrected, and
// used to sample the depth texture.  If the depth value for that fragment
// (effectively the distance from the light to the object at that point)
// is less than the Z component of that coordinate (effectively the distance
// from the light to the ground at that point) then that location is in shadow.
//
class GroundRenderer
{ … };

bool
GroundRenderer::setup(const mat4& projection, unsigned int texture)
{ … }

void
GroundRenderer::teardown()
{ … }

void
GroundRenderer::draw()
{ … }

class ShadowPrivate
{ … };

bool
ShadowPrivate::setup(map<string, Scene::Option>& options)
{ … }


void
ShadowPrivate::teardown()
{ … }

void
ShadowPrivate::update(double elapsedTime)
{ … }

void
ShadowPrivate::draw()
{ … }

SceneShadow::SceneShadow(Canvas& canvas) : … { … }

bool
SceneShadow::supported(bool show_errors)
{ … }

bool
SceneShadow::load()
{ … }

void
SceneShadow::unload()
{ … }

bool
SceneShadow::setup()
{ … }

void
SceneShadow::teardown()
{ … }

void
SceneShadow::update()
{ … }

void
SceneShadow::draw()
{ … }

Scene::ValidationResult
SceneShadow::validate()
{ … }