Import goldfish HAL sources from devices/generic/goldfish
We import all code here so we can customize and keep in sync with what we do on the host side more easily.
This commit is contained in:
Simon Fels
parent
ddea17253c
commit
23392b9732
196 changed files with 62159 additions and 0 deletions
478
android/camera/fake-pipeline2/Scene.cpp
Normal file
478
android/camera/fake-pipeline2/Scene.cpp
Normal file
|
|
@ -0,0 +1,478 @@
|
|||
/*
|
||||
* Copyright (C) 2012 The Android Open Source Project
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
//#define LOG_NDEBUG 0
|
||||
#define LOG_TAG "EmulatedCamera_Scene"
|
||||
#include <utils/Log.h>
|
||||
#include <stdlib.h>
|
||||
#include <cmath>
|
||||
#include "Scene.h"
|
||||
|
||||
// TODO: This should probably be done host-side in OpenGL for speed and better
|
||||
// quality
|
||||
|
||||
namespace android {
|
||||
|
||||
// Define single-letter shortcuts for scene definition, for directly indexing
|
||||
// mCurrentColors
|
||||
#define G (Scene::GRASS * Scene::NUM_CHANNELS)
|
||||
#define S (Scene::GRASS_SHADOW * Scene::NUM_CHANNELS)
|
||||
#define H (Scene::HILL * Scene::NUM_CHANNELS)
|
||||
#define W (Scene::WALL * Scene::NUM_CHANNELS)
|
||||
#define R (Scene::ROOF * Scene::NUM_CHANNELS)
|
||||
#define D (Scene::DOOR * Scene::NUM_CHANNELS)
|
||||
#define C (Scene::CHIMNEY * Scene::NUM_CHANNELS)
|
||||
#define I (Scene::WINDOW * Scene::NUM_CHANNELS)
|
||||
#define U (Scene::SUN * Scene::NUM_CHANNELS)
|
||||
#define K (Scene::SKY * Scene::NUM_CHANNELS)
|
||||
#define M (Scene::MOON * Scene::NUM_CHANNELS)
|
||||
|
||||
const int Scene::kSceneWidth = 20;
|
||||
const int Scene::kSceneHeight = 20;
|
||||
|
||||
const uint8_t Scene::kScene[Scene::kSceneWidth * Scene::kSceneHeight] = {
|
||||
// 5 10 15 20
|
||||
K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,
|
||||
K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,
|
||||
K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,
|
||||
K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,
|
||||
K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K, // 5
|
||||
K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,K,
|
||||
K,K,K,K,K,K,K,K,H,H,H,H,H,H,H,H,H,H,H,H,
|
||||
K,K,K,K,K,K,K,K,H,H,H,H,H,H,H,C,C,H,H,H,
|
||||
K,K,K,K,K,K,H,H,H,H,H,H,H,H,H,C,C,H,H,H,
|
||||
H,K,K,K,K,K,H,R,R,R,R,R,R,R,R,R,R,R,R,H, // 10
|
||||
H,K,K,K,K,H,H,R,R,R,R,R,R,R,R,R,R,R,R,H,
|
||||
H,H,H,K,K,H,H,R,R,R,R,R,R,R,R,R,R,R,R,H,
|
||||
H,H,H,K,K,H,H,H,W,W,W,W,W,W,W,W,W,W,H,H,
|
||||
S,S,S,G,G,S,S,S,W,W,W,W,W,W,W,W,W,W,S,S,
|
||||
S,G,G,G,G,S,S,S,W,I,I,W,D,D,W,I,I,W,S,S, // 15
|
||||
G,G,G,G,G,G,S,S,W,I,I,W,D,D,W,I,I,W,S,S,
|
||||
G,G,G,G,G,G,G,G,W,W,W,W,D,D,W,W,W,W,G,G,
|
||||
G,G,G,G,G,G,G,G,W,W,W,W,D,D,W,W,W,W,G,G,
|
||||
G,G,G,G,G,G,G,G,S,S,S,S,S,S,S,S,S,S,G,G,
|
||||
G,G,G,G,G,G,G,G,S,S,S,S,S,S,S,S,S,S,G,G, // 20
|
||||
// 5 10 15 20
|
||||
};
|
||||
|
||||
#undef G
|
||||
#undef S
|
||||
#undef H
|
||||
#undef W
|
||||
#undef R
|
||||
#undef D
|
||||
#undef C
|
||||
#undef I
|
||||
#undef U
|
||||
#undef K
|
||||
#undef M
|
||||
|
||||
Scene::Scene(
|
||||
int sensorWidthPx,
|
||||
int sensorHeightPx,
|
||||
float sensorSensitivity):
|
||||
mSensorWidth(sensorWidthPx),
|
||||
mSensorHeight(sensorHeightPx),
|
||||
mHour(12),
|
||||
mExposureDuration(0.033f),
|
||||
mSensorSensitivity(sensorSensitivity)
|
||||
{
|
||||
// Map scene to sensor pixels
|
||||
if (mSensorWidth > mSensorHeight) {
|
||||
mMapDiv = (mSensorWidth / (kSceneWidth + 1) ) + 1;
|
||||
} else {
|
||||
mMapDiv = (mSensorHeight / (kSceneHeight + 1) ) + 1;
|
||||
}
|
||||
mOffsetX = (kSceneWidth * mMapDiv - mSensorWidth) / 2;
|
||||
mOffsetY = (kSceneHeight * mMapDiv - mSensorHeight) / 2;
|
||||
|
||||
// Assume that sensor filters are sRGB primaries to start
|
||||
mFilterR[0] = 3.2406f; mFilterR[1] = -1.5372f; mFilterR[2] = -0.4986f;
|
||||
mFilterGr[0] = -0.9689f; mFilterGr[1] = 1.8758f; mFilterGr[2] = 0.0415f;
|
||||
mFilterGb[0] = -0.9689f; mFilterGb[1] = 1.8758f; mFilterGb[2] = 0.0415f;
|
||||
mFilterB[0] = 0.0557f; mFilterB[1] = -0.2040f; mFilterB[2] = 1.0570f;
|
||||
|
||||
|
||||
}
|
||||
|
||||
Scene::~Scene() {
|
||||
}
|
||||
|
||||
void Scene::setColorFilterXYZ(
|
||||
float rX, float rY, float rZ,
|
||||
float grX, float grY, float grZ,
|
||||
float gbX, float gbY, float gbZ,
|
||||
float bX, float bY, float bZ) {
|
||||
mFilterR[0] = rX; mFilterR[1] = rY; mFilterR[2] = rZ;
|
||||
mFilterGr[0] = grX; mFilterGr[1] = grY; mFilterGr[2] = grZ;
|
||||
mFilterGb[0] = gbX; mFilterGb[1] = gbY; mFilterGb[2] = gbZ;
|
||||
mFilterB[0] = bX; mFilterB[1] = bY; mFilterB[2] = bZ;
|
||||
}
|
||||
|
||||
void Scene::setHour(int hour) {
|
||||
ALOGV("Hour set to: %d", hour);
|
||||
mHour = hour % 24;
|
||||
}
|
||||
|
||||
int Scene::getHour() {
|
||||
return mHour;
|
||||
}
|
||||
|
||||
void Scene::setExposureDuration(float seconds) {
|
||||
mExposureDuration = seconds;
|
||||
}
|
||||
|
||||
void Scene::calculateScene(nsecs_t time) {
|
||||
// Calculate time fractions for interpolation
|
||||
int timeIdx = mHour / kTimeStep;
|
||||
int nextTimeIdx = (timeIdx + 1) % (24 / kTimeStep);
|
||||
const nsecs_t kOneHourInNsec = 1e9 * 60 * 60;
|
||||
nsecs_t timeSinceIdx = (mHour - timeIdx * kTimeStep) * kOneHourInNsec + time;
|
||||
float timeFrac = timeSinceIdx / (float)(kOneHourInNsec * kTimeStep);
|
||||
|
||||
// Determine overall sunlight levels
|
||||
float sunLux =
|
||||
kSunlight[timeIdx] * (1 - timeFrac) +
|
||||
kSunlight[nextTimeIdx] * timeFrac;
|
||||
ALOGV("Sun lux: %f", sunLux);
|
||||
|
||||
float sunShadeLux = sunLux * (kDaylightShadeIllum / kDirectSunIllum);
|
||||
|
||||
// Determine sun/shade illumination chromaticity
|
||||
float currentSunXY[2];
|
||||
float currentShadeXY[2];
|
||||
|
||||
const float *prevSunXY, *nextSunXY;
|
||||
const float *prevShadeXY, *nextShadeXY;
|
||||
if (kSunlight[timeIdx] == kSunsetIllum ||
|
||||
kSunlight[timeIdx] == kTwilightIllum) {
|
||||
prevSunXY = kSunsetXY;
|
||||
prevShadeXY = kSunsetXY;
|
||||
} else {
|
||||
prevSunXY = kDirectSunlightXY;
|
||||
prevShadeXY = kDaylightXY;
|
||||
}
|
||||
if (kSunlight[nextTimeIdx] == kSunsetIllum ||
|
||||
kSunlight[nextTimeIdx] == kTwilightIllum) {
|
||||
nextSunXY = kSunsetXY;
|
||||
nextShadeXY = kSunsetXY;
|
||||
} else {
|
||||
nextSunXY = kDirectSunlightXY;
|
||||
nextShadeXY = kDaylightXY;
|
||||
}
|
||||
currentSunXY[0] = prevSunXY[0] * (1 - timeFrac) +
|
||||
nextSunXY[0] * timeFrac;
|
||||
currentSunXY[1] = prevSunXY[1] * (1 - timeFrac) +
|
||||
nextSunXY[1] * timeFrac;
|
||||
|
||||
currentShadeXY[0] = prevShadeXY[0] * (1 - timeFrac) +
|
||||
nextShadeXY[0] * timeFrac;
|
||||
currentShadeXY[1] = prevShadeXY[1] * (1 - timeFrac) +
|
||||
nextShadeXY[1] * timeFrac;
|
||||
|
||||
ALOGV("Sun XY: %f, %f, Shade XY: %f, %f",
|
||||
currentSunXY[0], currentSunXY[1],
|
||||
currentShadeXY[0], currentShadeXY[1]);
|
||||
|
||||
// Converting for xyY to XYZ:
|
||||
// X = Y / y * x
|
||||
// Y = Y
|
||||
// Z = Y / y * (1 - x - y);
|
||||
float sunXYZ[3] = {
|
||||
sunLux / currentSunXY[1] * currentSunXY[0],
|
||||
sunLux,
|
||||
sunLux / currentSunXY[1] *
|
||||
(1 - currentSunXY[0] - currentSunXY[1])
|
||||
};
|
||||
float sunShadeXYZ[3] = {
|
||||
sunShadeLux / currentShadeXY[1] * currentShadeXY[0],
|
||||
sunShadeLux,
|
||||
sunShadeLux / currentShadeXY[1] *
|
||||
(1 - currentShadeXY[0] - currentShadeXY[1])
|
||||
};
|
||||
ALOGV("Sun XYZ: %f, %f, %f",
|
||||
sunXYZ[0], sunXYZ[1], sunXYZ[2]);
|
||||
ALOGV("Sun shade XYZ: %f, %f, %f",
|
||||
sunShadeXYZ[0], sunShadeXYZ[1], sunShadeXYZ[2]);
|
||||
|
||||
// Determine moonlight levels
|
||||
float moonLux =
|
||||
kMoonlight[timeIdx] * (1 - timeFrac) +
|
||||
kMoonlight[nextTimeIdx] * timeFrac;
|
||||
float moonShadeLux = moonLux * (kDaylightShadeIllum / kDirectSunIllum);
|
||||
|
||||
float moonXYZ[3] = {
|
||||
moonLux / kMoonlightXY[1] * kMoonlightXY[0],
|
||||
moonLux,
|
||||
moonLux / kMoonlightXY[1] *
|
||||
(1 - kMoonlightXY[0] - kMoonlightXY[1])
|
||||
};
|
||||
float moonShadeXYZ[3] = {
|
||||
moonShadeLux / kMoonlightXY[1] * kMoonlightXY[0],
|
||||
moonShadeLux,
|
||||
moonShadeLux / kMoonlightXY[1] *
|
||||
(1 - kMoonlightXY[0] - kMoonlightXY[1])
|
||||
};
|
||||
|
||||
// Determine starlight level
|
||||
const float kClearNightXYZ[3] = {
|
||||
kClearNightIllum / kMoonlightXY[1] * kMoonlightXY[0],
|
||||
kClearNightIllum,
|
||||
kClearNightIllum / kMoonlightXY[1] *
|
||||
(1 - kMoonlightXY[0] - kMoonlightXY[1])
|
||||
};
|
||||
|
||||
// Calculate direct and shaded light
|
||||
float directIllumXYZ[3] = {
|
||||
sunXYZ[0] + moonXYZ[0] + kClearNightXYZ[0],
|
||||
sunXYZ[1] + moonXYZ[1] + kClearNightXYZ[1],
|
||||
sunXYZ[2] + moonXYZ[2] + kClearNightXYZ[2],
|
||||
};
|
||||
|
||||
float shadeIllumXYZ[3] = {
|
||||
kClearNightXYZ[0],
|
||||
kClearNightXYZ[1],
|
||||
kClearNightXYZ[2]
|
||||
};
|
||||
|
||||
shadeIllumXYZ[0] += (mHour < kSunOverhead) ? sunXYZ[0] : sunShadeXYZ[0];
|
||||
shadeIllumXYZ[1] += (mHour < kSunOverhead) ? sunXYZ[1] : sunShadeXYZ[1];
|
||||
shadeIllumXYZ[2] += (mHour < kSunOverhead) ? sunXYZ[2] : sunShadeXYZ[2];
|
||||
|
||||
// Moon up period covers 23->0 transition, shift for simplicity
|
||||
int adjHour = (mHour + 12) % 24;
|
||||
int adjMoonOverhead = (kMoonOverhead + 12 ) % 24;
|
||||
shadeIllumXYZ[0] += (adjHour < adjMoonOverhead) ?
|
||||
moonXYZ[0] : moonShadeXYZ[0];
|
||||
shadeIllumXYZ[1] += (adjHour < adjMoonOverhead) ?
|
||||
moonXYZ[1] : moonShadeXYZ[1];
|
||||
shadeIllumXYZ[2] += (adjHour < adjMoonOverhead) ?
|
||||
moonXYZ[2] : moonShadeXYZ[2];
|
||||
|
||||
ALOGV("Direct XYZ: %f, %f, %f",
|
||||
directIllumXYZ[0],directIllumXYZ[1],directIllumXYZ[2]);
|
||||
ALOGV("Shade XYZ: %f, %f, %f",
|
||||
shadeIllumXYZ[0], shadeIllumXYZ[1], shadeIllumXYZ[2]);
|
||||
|
||||
for (int i = 0; i < NUM_MATERIALS; i++) {
|
||||
// Converting for xyY to XYZ:
|
||||
// X = Y / y * x
|
||||
// Y = Y
|
||||
// Z = Y / y * (1 - x - y);
|
||||
float matXYZ[3] = {
|
||||
kMaterials_xyY[i][2] / kMaterials_xyY[i][1] *
|
||||
kMaterials_xyY[i][0],
|
||||
kMaterials_xyY[i][2],
|
||||
kMaterials_xyY[i][2] / kMaterials_xyY[i][1] *
|
||||
(1 - kMaterials_xyY[i][0] - kMaterials_xyY[i][1])
|
||||
};
|
||||
|
||||
if (kMaterialsFlags[i] == 0 || kMaterialsFlags[i] & kSky) {
|
||||
matXYZ[0] *= directIllumXYZ[0];
|
||||
matXYZ[1] *= directIllumXYZ[1];
|
||||
matXYZ[2] *= directIllumXYZ[2];
|
||||
} else if (kMaterialsFlags[i] & kShadowed) {
|
||||
matXYZ[0] *= shadeIllumXYZ[0];
|
||||
matXYZ[1] *= shadeIllumXYZ[1];
|
||||
matXYZ[2] *= shadeIllumXYZ[2];
|
||||
} // else if (kMaterialsFlags[i] * kSelfLit), do nothing
|
||||
|
||||
ALOGV("Mat %d XYZ: %f, %f, %f", i, matXYZ[0], matXYZ[1], matXYZ[2]);
|
||||
float luxToElectrons = mSensorSensitivity * mExposureDuration /
|
||||
(kAperture * kAperture);
|
||||
mCurrentColors[i*NUM_CHANNELS + 0] =
|
||||
(mFilterR[0] * matXYZ[0] +
|
||||
mFilterR[1] * matXYZ[1] +
|
||||
mFilterR[2] * matXYZ[2])
|
||||
* luxToElectrons;
|
||||
mCurrentColors[i*NUM_CHANNELS + 1] =
|
||||
(mFilterGr[0] * matXYZ[0] +
|
||||
mFilterGr[1] * matXYZ[1] +
|
||||
mFilterGr[2] * matXYZ[2])
|
||||
* luxToElectrons;
|
||||
mCurrentColors[i*NUM_CHANNELS + 2] =
|
||||
(mFilterGb[0] * matXYZ[0] +
|
||||
mFilterGb[1] * matXYZ[1] +
|
||||
mFilterGb[2] * matXYZ[2])
|
||||
* luxToElectrons;
|
||||
mCurrentColors[i*NUM_CHANNELS + 3] =
|
||||
(mFilterB[0] * matXYZ[0] +
|
||||
mFilterB[1] * matXYZ[1] +
|
||||
mFilterB[2] * matXYZ[2])
|
||||
* luxToElectrons;
|
||||
|
||||
ALOGV("Color %d RGGB: %d, %d, %d, %d", i,
|
||||
mCurrentColors[i*NUM_CHANNELS + 0],
|
||||
mCurrentColors[i*NUM_CHANNELS + 1],
|
||||
mCurrentColors[i*NUM_CHANNELS + 2],
|
||||
mCurrentColors[i*NUM_CHANNELS + 3]);
|
||||
}
|
||||
// Shake viewpoint; horizontal and vertical sinusoids at roughly
|
||||
// human handshake frequencies
|
||||
mHandshakeX =
|
||||
( kFreq1Magnitude * std::sin(kHorizShakeFreq1 * timeSinceIdx) +
|
||||
kFreq2Magnitude * std::sin(kHorizShakeFreq2 * timeSinceIdx) ) *
|
||||
mMapDiv * kShakeFraction;
|
||||
|
||||
mHandshakeY =
|
||||
( kFreq1Magnitude * std::sin(kVertShakeFreq1 * timeSinceIdx) +
|
||||
kFreq2Magnitude * std::sin(kVertShakeFreq2 * timeSinceIdx) ) *
|
||||
mMapDiv * kShakeFraction;
|
||||
|
||||
// Set starting pixel
|
||||
setReadoutPixel(0,0);
|
||||
}
|
||||
|
||||
void Scene::setReadoutPixel(int x, int y) {
|
||||
mCurrentX = x;
|
||||
mCurrentY = y;
|
||||
mSubX = (x + mOffsetX + mHandshakeX) % mMapDiv;
|
||||
mSubY = (y + mOffsetY + mHandshakeY) % mMapDiv;
|
||||
mSceneX = (x + mOffsetX + mHandshakeX) / mMapDiv;
|
||||
mSceneY = (y + mOffsetY + mHandshakeY) / mMapDiv;
|
||||
mSceneIdx = mSceneY * kSceneWidth + mSceneX;
|
||||
mCurrentSceneMaterial = &(mCurrentColors[kScene[mSceneIdx]]);
|
||||
}
|
||||
|
||||
const uint32_t* Scene::getPixelElectrons() {
|
||||
const uint32_t *pixel = mCurrentSceneMaterial;
|
||||
mCurrentX++;
|
||||
mSubX++;
|
||||
if (mCurrentX >= mSensorWidth) {
|
||||
mCurrentX = 0;
|
||||
mCurrentY++;
|
||||
if (mCurrentY >= mSensorHeight) mCurrentY = 0;
|
||||
setReadoutPixel(mCurrentX, mCurrentY);
|
||||
} else if (mSubX > mMapDiv) {
|
||||
mSceneIdx++;
|
||||
mSceneX++;
|
||||
mCurrentSceneMaterial = &(mCurrentColors[kScene[mSceneIdx]]);
|
||||
mSubX = 0;
|
||||
}
|
||||
return pixel;
|
||||
}
|
||||
|
||||
// Handshake model constants.
|
||||
// Frequencies measured in a nanosecond timebase
|
||||
const float Scene::kHorizShakeFreq1 = 2 * M_PI * 2 / 1e9; // 2 Hz
|
||||
const float Scene::kHorizShakeFreq2 = 2 * M_PI * 13 / 1e9; // 13 Hz
|
||||
const float Scene::kVertShakeFreq1 = 2 * M_PI * 3 / 1e9; // 3 Hz
|
||||
const float Scene::kVertShakeFreq2 = 2 * M_PI * 11 / 1e9; // 1 Hz
|
||||
const float Scene::kFreq1Magnitude = 5;
|
||||
const float Scene::kFreq2Magnitude = 1;
|
||||
const float Scene::kShakeFraction = 0.03; // As a fraction of a scene tile
|
||||
|
||||
// RGB->YUV, Jpeg standard
|
||||
const float Scene::kRgb2Yuv[12] = {
|
||||
0.299f, 0.587f, 0.114f, 0.f,
|
||||
-0.16874f, -0.33126f, 0.5f, -128.f,
|
||||
0.5f, -0.41869f, -0.08131f, -128.f,
|
||||
};
|
||||
|
||||
// Aperture of imaging lens
|
||||
const float Scene::kAperture = 2.8;
|
||||
|
||||
// Sun illumination levels through the day
|
||||
const float Scene::kSunlight[24/kTimeStep] =
|
||||
{
|
||||
0, // 00:00
|
||||
0,
|
||||
0,
|
||||
kTwilightIllum, // 06:00
|
||||
kDirectSunIllum,
|
||||
kDirectSunIllum,
|
||||
kDirectSunIllum, // 12:00
|
||||
kDirectSunIllum,
|
||||
kDirectSunIllum,
|
||||
kSunsetIllum, // 18:00
|
||||
kTwilightIllum,
|
||||
0
|
||||
};
|
||||
|
||||
// Moon illumination levels through the day
|
||||
const float Scene::kMoonlight[24/kTimeStep] =
|
||||
{
|
||||
kFullMoonIllum, // 00:00
|
||||
kFullMoonIllum,
|
||||
0,
|
||||
0, // 06:00
|
||||
0,
|
||||
0,
|
||||
0, // 12:00
|
||||
0,
|
||||
0,
|
||||
0, // 18:00
|
||||
0,
|
||||
kFullMoonIllum
|
||||
};
|
||||
|
||||
const int Scene::kSunOverhead = 12;
|
||||
const int Scene::kMoonOverhead = 0;
|
||||
|
||||
// Used for sun illumination levels
|
||||
const float Scene::kDirectSunIllum = 100000;
|
||||
const float Scene::kSunsetIllum = 400;
|
||||
const float Scene::kTwilightIllum = 4;
|
||||
// Used for moon illumination levels
|
||||
const float Scene::kFullMoonIllum = 1;
|
||||
// Other illumination levels
|
||||
const float Scene::kDaylightShadeIllum = 20000;
|
||||
const float Scene::kClearNightIllum = 2e-3;
|
||||
const float Scene::kStarIllum = 2e-6;
|
||||
const float Scene::kLivingRoomIllum = 50;
|
||||
|
||||
const float Scene::kIncandescentXY[2] = { 0.44757f, 0.40745f};
|
||||
const float Scene::kDirectSunlightXY[2] = { 0.34842f, 0.35161f};
|
||||
const float Scene::kDaylightXY[2] = { 0.31271f, 0.32902f};
|
||||
const float Scene::kNoonSkyXY[2] = { 0.346f, 0.359f};
|
||||
const float Scene::kMoonlightXY[2] = { 0.34842f, 0.35161f};
|
||||
const float Scene::kSunsetXY[2] = { 0.527f, 0.413f};
|
||||
|
||||
const uint8_t Scene::kSelfLit = 0x01;
|
||||
const uint8_t Scene::kShadowed = 0x02;
|
||||
const uint8_t Scene::kSky = 0x04;
|
||||
|
||||
// For non-self-lit materials, the Y component is normalized with 1=full
|
||||
// reflectance; for self-lit materials, it's the constant illuminance in lux.
|
||||
const float Scene::kMaterials_xyY[Scene::NUM_MATERIALS][3] = {
|
||||
{ 0.3688f, 0.4501f, .1329f }, // GRASS
|
||||
{ 0.3688f, 0.4501f, .1329f }, // GRASS_SHADOW
|
||||
{ 0.3986f, 0.5002f, .4440f }, // HILL
|
||||
{ 0.3262f, 0.5040f, .2297f }, // WALL
|
||||
{ 0.4336f, 0.3787f, .1029f }, // ROOF
|
||||
{ 0.3316f, 0.2544f, .0639f }, // DOOR
|
||||
{ 0.3425f, 0.3577f, .0887f }, // CHIMNEY
|
||||
{ kIncandescentXY[0], kIncandescentXY[1], kLivingRoomIllum }, // WINDOW
|
||||
{ kDirectSunlightXY[0], kDirectSunlightXY[1], kDirectSunIllum }, // SUN
|
||||
{ kNoonSkyXY[0], kNoonSkyXY[1], kDaylightShadeIllum / kDirectSunIllum }, // SKY
|
||||
{ kMoonlightXY[0], kMoonlightXY[1], kFullMoonIllum } // MOON
|
||||
};
|
||||
|
||||
const uint8_t Scene::kMaterialsFlags[Scene::NUM_MATERIALS] = {
|
||||
0,
|
||||
kShadowed,
|
||||
kShadowed,
|
||||
kShadowed,
|
||||
kShadowed,
|
||||
kShadowed,
|
||||
kShadowed,
|
||||
kSelfLit,
|
||||
kSelfLit,
|
||||
kSky,
|
||||
kSelfLit,
|
||||
};
|
||||
|
||||
} // namespace android
|
||||
Loading…
Add table
Add a link
Reference in a new issue