187 lines
6.4 KiB
C++
187 lines
6.4 KiB
C++
|
/*
|
||
|
|
Copyright (c) 2005-2019 Intel Corporation
|
||
|
|
|
||
|
|
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.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include "video.h"
|
||
|
|
#include <cmath>
|
||
|
|
|
||
|
|
using namespace std;
|
||
|
|
|
||
|
|
#ifdef _MSC_VER
|
||
|
|
// warning C4068: unknown pragma
|
||
|
|
#pragma warning(disable: 4068)
|
||
|
|
// warning C4351: new behavior: elements of array 'array' will be default initialized
|
||
|
|
#pragma warning(disable: 4351)
|
||
|
|
#endif
|
||
|
|
|
||
|
|
#include "universe.h"
|
||
|
|
|
||
|
|
const colorcomp_t MaterialColor[4][3] = { // BGR
|
||
|
|
{96,0,0}, // WATER
|
||
|
|
{0,48,48}, // SANDSTONE
|
||
|
|
{32,32,23} // SHALE
|
||
|
|
};
|
||
|
|
|
||
|
|
void Universe::InitializeUniverse(video const& colorizer) {
|
||
|
|
|
||
|
|
pulseCounter = pulseTime = 100;
|
||
|
|
pulseX = UniverseWidth/3;
|
||
|
|
pulseY = UniverseHeight/4;
|
||
|
|
// Initialize V, S, and T to slightly non-zero values, in order to avoid denormal waves.
|
||
|
|
for( int i=0; i<UniverseHeight; ++i )
|
||
|
|
#pragma ivdep
|
||
|
|
for( int j=0; j<UniverseWidth; ++j ) {
|
||
|
|
T[i][j] = S[i][j] = V[i][j] = ValueType(1.0E-6);
|
||
|
|
}
|
||
|
|
for( int i=1; i<UniverseHeight-1; ++i ) {
|
||
|
|
for( int j=1; j<UniverseWidth-1; ++j ) {
|
||
|
|
float x = float(j-UniverseWidth/2)/(UniverseWidth/2);
|
||
|
|
ValueType t = (ValueType)i/UniverseHeight;
|
||
|
|
MaterialType m;
|
||
|
|
D[i][j] = 1.0;
|
||
|
|
// Coefficient values are fictitious, and chosen to visually exaggerate
|
||
|
|
// physical effects such as Rayleigh waves. The fabs/exp line generates
|
||
|
|
// a shale layer with a gentle upwards slope and an anticline.
|
||
|
|
if( t<0.3f ) {
|
||
|
|
m = WATER;
|
||
|
|
M[i][j] = 0.125;
|
||
|
|
L[i][j] = 0.125;
|
||
|
|
} else if( fabs(t-0.7+0.2*exp(-8*x*x)+0.025*x)<=0.1 ) {
|
||
|
|
m = SHALE;
|
||
|
|
M[i][j] = 0.5;
|
||
|
|
L[i][j] = 0.6;
|
||
|
|
} else {
|
||
|
|
m = SANDSTONE;
|
||
|
|
M[i][j] = 0.3;
|
||
|
|
L[i][j] = 0.4;
|
||
|
|
}
|
||
|
|
material[i][j] = m;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
ValueType scale = 2.0f/ColorMapSize;
|
||
|
|
for( int k=0; k<4; ++k ) {
|
||
|
|
for( int i=0; i<ColorMapSize; ++i ) {
|
||
|
|
colorcomp_t c[3];
|
||
|
|
ValueType t = (i-ColorMapSize/2)*scale;
|
||
|
|
ValueType r = t>0 ? t : 0;
|
||
|
|
ValueType b = t<0 ? -t : 0;
|
||
|
|
ValueType g = 0.5f*fabs(t);
|
||
|
|
std::memcpy(c, MaterialColor[k], sizeof(c));
|
||
|
|
c[2] = colorcomp_t(r*(255-c[2])+c[2]);
|
||
|
|
c[1] = colorcomp_t(g*(255-c[1])+c[1]);
|
||
|
|
c[0] = colorcomp_t(b*(255-c[0])+c[0]);
|
||
|
|
ColorMap[k][i] = colorizer.get_color(c[2], c[1], c[0]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Set damping coefficients around border to reduce reflections from boundaries.
|
||
|
|
ValueType d = 1.0;
|
||
|
|
for( int k=DamperSize-1; k>0; --k ) {
|
||
|
|
d *= 1-1.0f/(DamperSize*DamperSize);
|
||
|
|
for( int j=1; j<UniverseWidth-1; ++j ) {
|
||
|
|
D[k][j] *= d;
|
||
|
|
D[UniverseHeight-1-k][j] *= d;
|
||
|
|
}
|
||
|
|
for( int i=1; i<UniverseHeight-1; ++i ) {
|
||
|
|
D[i][k] *= d;
|
||
|
|
D[i][UniverseWidth-1-k] *= d;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
drawingMemory = colorizer.get_drawing_memory();
|
||
|
|
}
|
||
|
|
void Universe::UpdatePulse() {
|
||
|
|
if( pulseCounter>0 ) {
|
||
|
|
ValueType t = (pulseCounter-pulseTime/2)*0.05f;
|
||
|
|
V[pulseY][pulseX] += 64*sqrt(M[pulseY][pulseX])*exp(-t*t);
|
||
|
|
--pulseCounter;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void Universe::UpdateStress(Rectangle const& r ) {
|
||
|
|
drawing_area drawing(r.StartX(),r.StartY(),r.Width(),r.Height(),drawingMemory);
|
||
|
|
for( int i=r.StartY(); i<r.EndY() ; ++i ) {
|
||
|
|
drawing.set_pos(1, i-r.StartY());
|
||
|
|
#pragma ivdep
|
||
|
|
for( int j=r.StartX(); j<r.EndX() ; ++j ) {
|
||
|
|
S[i][j] += M[i][j]*(V[i][j+1]-V[i][j]);
|
||
|
|
T[i][j] += M[i][j]*(V[i+1][j]-V[i][j]);
|
||
|
|
int index = (int)(V[i][j]*(ColorMapSize/2)) + ColorMapSize/2;
|
||
|
|
if( index<0 ) index = 0;
|
||
|
|
if( index>=ColorMapSize ) index = ColorMapSize-1;
|
||
|
|
color_t* c = ColorMap[material[i][j]];
|
||
|
|
drawing.put_pixel(c[index]);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void Universe::SerialUpdateStress() {
|
||
|
|
Rectangle area(0, 0, UniverseWidth-1, UniverseHeight-1);
|
||
|
|
UpdateStress(area);
|
||
|
|
}
|
||
|
|
|
||
|
|
//void Universe::ParallelUpdateStress(tbb::affinity_partitioner &affinity) {
|
||
|
|
// tbb::parallel_for( tbb::blocked_range<int>( 0, UniverseHeight-1 ), // Index space for loop
|
||
|
|
// UpdateStressBody(*this), // Body of loop
|
||
|
|
// affinity ); // Affinity hint
|
||
|
|
//}
|
||
|
|
|
||
|
|
void Universe::UpdateVelocity(Rectangle const& r) {
|
||
|
|
for( int i=r.StartY(); i<r.EndY(); ++i )
|
||
|
|
#pragma ivdep
|
||
|
|
for( int j=r.StartX(); j<r.EndX(); ++j )
|
||
|
|
V[i][j] = D[i][j]*(V[i][j] + L[i][j]*(S[i][j] - S[i][j-1] + T[i][j] - T[i-1][j]));
|
||
|
|
}
|
||
|
|
|
||
|
|
void Universe::SerialUpdateVelocity() {
|
||
|
|
UpdateVelocity(Rectangle(1,1,UniverseWidth-1,UniverseHeight-1));
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
//void Universe::ParallelUpdateVelocity(tbb::affinity_partitioner &affinity) {
|
||
|
|
// tbb::parallel_for( tbb::blocked_range<int>( 1, UniverseHeight ), // Index space for loop
|
||
|
|
// UpdateVelocityBody(*this), // Body of loop
|
||
|
|
// affinity ); // Affinity hint
|
||
|
|
//}
|
||
|
|
|
||
|
|
void Universe::SerialUpdateUniverse() {
|
||
|
|
UpdatePulse();
|
||
|
|
SerialUpdateStress();
|
||
|
|
SerialUpdateVelocity();
|
||
|
|
}
|
||
|
|
|
||
|
|
//void Universe::ParallelUpdateUniverse() {
|
||
|
|
// /** Affinity is an argument to parallel_for to hint that an iteration of a loop
|
||
|
|
// is best replayed on the same processor for each execution of the loop.
|
||
|
|
// It is a static object because it must remember where the iterations happened
|
||
|
|
// in previous executions. */
|
||
|
|
// static tbb::affinity_partitioner affinity;
|
||
|
|
// UpdatePulse();
|
||
|
|
// ParallelUpdateStress(affinity);
|
||
|
|
// ParallelUpdateVelocity(affinity);
|
||
|
|
//}
|
||
|
|
|
||
|
|
bool Universe::TryPutNewPulseSource(int x, int y){
|
||
|
|
if(pulseCounter == 0) {
|
||
|
|
pulseCounter = pulseTime;
|
||
|
|
pulseX = x; pulseY = y;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
void Universe::SetDrawingMemory(const drawing_memory &dmem) {
|
||
|
|
drawingMemory = dmem;
|
||
|
|
}
|