351 lines
11 KiB
C++
351 lines
11 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//===========================================================================//
|
|
|
|
#include <tier0/platform.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
#include "bitmap/float_bm.h"
|
|
#include "vstdlib/vstdlib.h"
|
|
#include "raytrace.h"
|
|
#include "mathlib/bumpvects.h"
|
|
#include "mathlib/halton.h"
|
|
#include "tier0/threadtools.h"
|
|
#include "tier0/progressbar.h"
|
|
|
|
// In order to handle intersections with wrapped copies, we repeat the bitmap triangles this many
|
|
// times
|
|
#define NREPS_TILE 1
|
|
extern int n_intersection_calculations;
|
|
|
|
|
|
|
|
struct SSBumpCalculationContext // what each thread needs to see
|
|
{
|
|
RayTracingEnvironment *m_pRtEnv;
|
|
FloatBitMap_t *ret_bm; // the bitmnap we are building
|
|
FloatBitMap_t const *src_bm;
|
|
int nrays_to_trace_per_pixel;
|
|
float bump_scale;
|
|
Vector *trace_directions; // light source directions to trace
|
|
Vector *normals;
|
|
int min_y; // range of scanlines to computer for
|
|
int max_y;
|
|
uint32 m_nOptionFlags;
|
|
int thread_number;
|
|
};
|
|
|
|
|
|
static unsigned SSBumpCalculationThreadFN( void * ctx1 )
|
|
{
|
|
SSBumpCalculationContext *ctx = ( SSBumpCalculationContext * ) ctx1;
|
|
|
|
RayStream ray_trace_stream_ctx;
|
|
|
|
RayTracingSingleResult * rslts = new
|
|
RayTracingSingleResult[ctx->ret_bm->Width * ctx->nrays_to_trace_per_pixel];
|
|
|
|
|
|
for( int y = ctx->min_y; y <= ctx->max_y; y++ )
|
|
{
|
|
if ( ctx->thread_number == 0 )
|
|
ReportProgress("Computing output",(1+ctx->max_y-ctx->min_y),y-ctx->min_y);
|
|
for( int r = 0; r < ctx->nrays_to_trace_per_pixel; r++ )
|
|
{
|
|
for( int x = 0; x < ctx->ret_bm->Width; x++ )
|
|
{
|
|
Vector surf_pnt( x, y, ctx->bump_scale * ctx->src_bm->Pixel( x, y, 3 ) );
|
|
// move the ray origin up a hair
|
|
surf_pnt.z += 0.55;
|
|
Vector trace_end = surf_pnt;
|
|
Vector trace_dir = ctx->trace_directions[ r ];
|
|
trace_dir *= ( 1 + NREPS_TILE * 2 ) * max( ctx->src_bm->Width, ctx->src_bm->Height );
|
|
trace_end += trace_dir;
|
|
ctx->m_pRtEnv->AddToRayStream( ray_trace_stream_ctx, surf_pnt, trace_end,
|
|
& ( rslts[ r + ctx->nrays_to_trace_per_pixel * ( x )] ));
|
|
}
|
|
}
|
|
if ( ctx->nrays_to_trace_per_pixel )
|
|
ctx->m_pRtEnv->FinishRayStream( ray_trace_stream_ctx );
|
|
// now, all ray tracing results are in the results buffer. Determine the visible self-shadowed
|
|
// bump map lighting at each vertex in each basis direction
|
|
for( int x = 0; x < ctx->src_bm->Width; x++ )
|
|
{
|
|
int nNumChannels = ( ctx->m_nOptionFlags & SSBUMP_OPTION_NONDIRECTIONAL ) ? 1 : 3;
|
|
for( int c = 0; c < nNumChannels; c++ )
|
|
{
|
|
float sum_dots = 0;
|
|
float sum_possible_dots = 0;
|
|
Vector ldir = g_localBumpBasis[c];
|
|
float ndotl = DotProduct( ldir, ctx->normals[x + y * ctx->src_bm->Width] );
|
|
if ( ndotl < 0 )
|
|
ctx->ret_bm->Pixel( x, y, c ) = 0;
|
|
else
|
|
{
|
|
if ( ctx->nrays_to_trace_per_pixel )
|
|
{
|
|
RayTracingSingleResult *this_rslt =
|
|
rslts + ctx->nrays_to_trace_per_pixel * ( x );
|
|
for( int r = 0; r < ctx->nrays_to_trace_per_pixel; r++ )
|
|
{
|
|
float dot;
|
|
if ( ctx->m_nOptionFlags & SSBUMP_OPTION_NONDIRECTIONAL )
|
|
dot = ctx->trace_directions[r].z;
|
|
else
|
|
dot = DotProduct( ldir, ctx->trace_directions[r] );
|
|
if ( dot > 0 )
|
|
{
|
|
sum_possible_dots += dot;
|
|
if ( this_rslt[r].HitID == - 1 )
|
|
sum_dots += dot;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
sum_dots = sum_possible_dots = 1.0;
|
|
}
|
|
ctx->ret_bm->Pixel( x, y, c ) = ( ndotl * sum_dots ) / sum_possible_dots;
|
|
}
|
|
}
|
|
if ( ctx->m_nOptionFlags & SSBUMP_OPTION_NONDIRECTIONAL )
|
|
{
|
|
ctx->ret_bm->Pixel( x, y, 1 ) = ctx->ret_bm->Pixel( x, y, 0 ); // copy height
|
|
ctx->ret_bm->Pixel( x, y, 2 ) = ctx->ret_bm->Pixel( x, y, 0 ); // copy height
|
|
ctx->ret_bm->Pixel( x, y, 3 ) = ctx->ret_bm->Pixel( x, y, 0 ); // copy height
|
|
}
|
|
else
|
|
{
|
|
ctx->ret_bm->Pixel( x, y, 3 ) = ctx->src_bm->Pixel( x, y, 3 ); // copy height
|
|
}
|
|
}
|
|
}
|
|
delete[] rslts;
|
|
return 0;
|
|
}
|
|
|
|
void FloatBitMap_t::ComputeVertexPositionsAndNormals( float flHeightScale, Vector **ppPosOut, Vector **ppNormalOut ) const
|
|
{
|
|
Vector *verts = new Vector[Width * Height];
|
|
// first, calculate vertex positions
|
|
for( int y = 0; y < Height; y++ )
|
|
for( int x = 0; x < Width; x++ )
|
|
{
|
|
Vector * out = verts + x + y * Width;
|
|
out->x = x;
|
|
out->y = y;
|
|
out->z = flHeightScale * Pixel( x, y, 3 );
|
|
}
|
|
|
|
Vector *normals = new Vector[Width * Height];
|
|
// now, calculate normals, smoothed
|
|
for( int y = 0; y < Height; y++ )
|
|
for( int x = 0; x < Width; x++ )
|
|
{
|
|
// now, calculcate average normal
|
|
Vector avg_normal( 0, 0, 0 );
|
|
for( int xofs =- 1;xofs <= 1;xofs++ )
|
|
for( int yofs =- 1;yofs <= 1;yofs++ )
|
|
{
|
|
int x0 = ( x + xofs );
|
|
if ( x0 < 0 )
|
|
x0 += Width;
|
|
int y0 = ( y + yofs );
|
|
if ( y0 < 0 )
|
|
y0 += Height;
|
|
x0 = x0 % Width;
|
|
y0 = y0 % Height;
|
|
int x1 = ( x0 + 1 ) % Width;
|
|
int y1 = ( y0 + 1 ) % Height;
|
|
// now, form the two triangles from this vertex
|
|
Vector p0 = verts[x0 + y0 * Width];
|
|
Vector e1 = verts[x1 + y0 * Width];
|
|
e1 -= p0;
|
|
Vector e2 = verts[x0 + y1 * Width];
|
|
e2 -= p0;
|
|
Vector n1;
|
|
CrossProduct( e1, e2, n1 );
|
|
if ( n1.z < 0 )
|
|
n1.Negate();
|
|
e1 = verts[x + y1 * Width];
|
|
e1 -= p0;
|
|
e2 = verts[x1 + y1 * Width];
|
|
e2 -= p0;
|
|
Vector n2;
|
|
CrossProduct( e1, e2, n2 );
|
|
if ( n2.z < 0 )
|
|
n2.Negate();
|
|
n1.NormalizeInPlace();
|
|
n2.NormalizeInPlace();
|
|
avg_normal += n1;
|
|
avg_normal += n2;
|
|
}
|
|
avg_normal.NormalizeInPlace();
|
|
normals[x + y * Width]= avg_normal;
|
|
}
|
|
*ppPosOut = verts;
|
|
*ppNormalOut = normals;
|
|
}
|
|
|
|
FloatBitMap_t *FloatBitMap_t::ComputeSelfShadowedBumpmapFromHeightInAlphaChannel(
|
|
float bump_scale, int nrays_to_trace_per_pixel,
|
|
uint32 nOptionFlags ) const
|
|
{
|
|
|
|
// first, add all the triangles from the height map to the "world".
|
|
// we will make multiple copies to handle wrapping
|
|
int tcnt = 1;
|
|
|
|
Vector * verts;
|
|
Vector * normals;
|
|
ComputeVertexPositionsAndNormals( bump_scale, & verts, & normals );
|
|
|
|
RayTracingEnvironment rtEnv;
|
|
rtEnv.Flags |= RTE_FLAGS_DONT_STORE_TRIANGLE_COLORS; // save some ram
|
|
|
|
if ( nrays_to_trace_per_pixel )
|
|
{
|
|
rtEnv.MakeRoomForTriangles( ( 1 + 2 * NREPS_TILE ) * ( 1 + 2 * NREPS_TILE ) * 2 * Height * Width );
|
|
|
|
// now, add a whole mess of triangles to trace against
|
|
for( int tilex =- NREPS_TILE; tilex <= NREPS_TILE; tilex++ )
|
|
for( int tiley =- NREPS_TILE; tiley <= NREPS_TILE; tiley++ )
|
|
{
|
|
int min_x = 0;
|
|
int max_x = Width - 1;
|
|
int min_y = 0;
|
|
int max_y = Height - 1;
|
|
if ( tilex < 0 )
|
|
min_x = Width / 2;
|
|
if ( tilex > 0 )
|
|
max_x = Width / 2;
|
|
if ( tiley < 0 )
|
|
min_y = Height / 2;
|
|
if ( tiley > 0 )
|
|
max_y = Height / 2;
|
|
for( int y = min_y; y <= max_y; y++ )
|
|
for( int x = min_x; x <= max_x; x++ )
|
|
{
|
|
Vector ofs( tilex * Width, tiley * Height, 0 );
|
|
int x1 = ( x + 1 ) % Width;
|
|
int y1 = ( y + 1 ) % Height;
|
|
Vector v0 = verts[x + y * Width];
|
|
Vector v1 = verts[x1 + y * Width];
|
|
Vector v2 = verts[x1 + y1 * Width];
|
|
Vector v3 = verts[x + y1 * Width];
|
|
v0.x = x; v0.y = y;
|
|
v1.x = x + 1; v1.y = y;
|
|
v2.x = x + 1; v2.y = y + 1;
|
|
v3.x = x; v3.y = y + 1;
|
|
v0 += ofs; v1 += ofs; v2 += ofs; v3 += ofs;
|
|
rtEnv.AddTriangle( tcnt++, v0, v1, v2, Vector( 1, 1, 1 ) );
|
|
rtEnv.AddTriangle( tcnt++, v0, v3, v2, Vector( 1, 1, 1 ) );
|
|
}
|
|
}
|
|
//printf("added %d triangles\n",tcnt-1);
|
|
ReportProgress("Creating kd-tree",0,0);
|
|
rtEnv.SetupAccelerationStructure();
|
|
// ok, now we have built a structure for ray intersection. we will take advantage
|
|
// of the SSE ray tracing code by intersecting rays as a batch.
|
|
}
|
|
|
|
// We need to calculate for each vertex (i.e. pixel) of the heightmap, how "much" of the world
|
|
// it can see in each basis direction. we will do this by sampling a sphere of rays around the
|
|
// vertex, and using dot-product weighting to measure the lighting contribution in each basis
|
|
// direction. note that the surface normal is not used here. The surface normal will end up
|
|
// being reflected in the result because of rays being blocked when they try to pass through
|
|
// the planes of the triangles touching the vertex.
|
|
|
|
// note that there is no reason inter-bounced lighting could not be folded into this
|
|
// calculation.
|
|
|
|
FloatBitMap_t * ret = new FloatBitMap_t( Width, Height );
|
|
|
|
|
|
Vector *trace_directions=new Vector[nrays_to_trace_per_pixel];
|
|
DirectionalSampler_t my_sphere_sampler;
|
|
for( int r=0; r < nrays_to_trace_per_pixel; r++)
|
|
{
|
|
Vector trace_dir=my_sphere_sampler.NextValue();
|
|
// trace_dir=Vector(1,0,0);
|
|
trace_dir.z=fabs(trace_dir.z); // upwards facing only
|
|
trace_directions[ r ]= trace_dir;
|
|
}
|
|
|
|
volatile SSBumpCalculationContext ctxs[32];
|
|
ctxs[0].m_pRtEnv =& rtEnv;
|
|
ctxs[0].ret_bm = ret;
|
|
ctxs[0].src_bm = this;
|
|
ctxs[0].nrays_to_trace_per_pixel = nrays_to_trace_per_pixel;
|
|
ctxs[0].bump_scale = bump_scale;
|
|
ctxs[0].trace_directions = trace_directions;
|
|
ctxs[0].normals = normals;
|
|
ctxs[0].min_y = 0;
|
|
ctxs[0].max_y = Height - 1;
|
|
ctxs[0].m_nOptionFlags = nOptionFlags;
|
|
int nthreads = min( 32, (int)GetCPUInformation()->m_nPhysicalProcessors );
|
|
|
|
ThreadHandle_t waithandles[32];
|
|
int starty = 0;
|
|
int ystep = Height / nthreads;
|
|
for( int t = 0;t < nthreads; t++ )
|
|
{
|
|
if ( t )
|
|
memcpy( (void * ) ( & ctxs[t] ), ( void * ) & ctxs[0], sizeof( ctxs[0] ));
|
|
ctxs[t].thread_number = t;
|
|
ctxs[t].min_y = starty;
|
|
if ( t != nthreads - 1 )
|
|
ctxs[t].max_y = min( Height - 1, starty + ystep - 1 );
|
|
else
|
|
ctxs[t].max_y = Height - 1;
|
|
waithandles[t]= CreateSimpleThread( SSBumpCalculationThreadFN, ( SSBumpCalculationContext * ) & ctxs[t] );
|
|
starty += ystep;
|
|
}
|
|
for(int t=0;t<nthreads;t++)
|
|
{
|
|
ThreadJoin( waithandles[t] );
|
|
}
|
|
if ( nOptionFlags & SSBUMP_MOD2X_DETAIL_TEXTURE )
|
|
{
|
|
const float flOutputScale = 0.5 * ( 1.0 / .57735026 ); // normalize so that a flat normal yields 0.5
|
|
// scale output weights by color channel
|
|
for( int nY = 0; nY < Height; nY++ )
|
|
for( int nX = 0; nX < Width; nX++ )
|
|
{
|
|
float flScale = flOutputScale * (2.0/3.0) * ( Pixel( nX, nY, 0 ) + Pixel( nX, nY, 1 ) + Pixel( nX, nY, 2 ) );
|
|
ret->Pixel( nX, nY, 0 ) *= flScale;
|
|
ret->Pixel( nX, nY, 1 ) *= flScale;
|
|
ret->Pixel( nX, nY, 2 ) *= flScale;
|
|
}
|
|
}
|
|
|
|
delete[] verts;
|
|
delete[] trace_directions;
|
|
delete[] normals;
|
|
return ret; // destructor will clean up rtenv
|
|
}
|
|
|
|
// generate a conventional normal map from a source with height stored in alpha.
|
|
FloatBitMap_t *FloatBitMap_t::ComputeBumpmapFromHeightInAlphaChannel( float bump_scale ) const
|
|
{
|
|
Vector *verts;
|
|
Vector *normals;
|
|
ComputeVertexPositionsAndNormals( bump_scale, &verts, &normals );
|
|
FloatBitMap_t *ret=new FloatBitMap_t( Width, Height );
|
|
for( int y = 0; y < Height; y++ )
|
|
for( int x = 0; x < Width; x++ )
|
|
{
|
|
Vector const & N = normals[ x + y * Width ];
|
|
ret->Pixel( x, y, 0 ) = 0.5+ 0.5 * N.x;
|
|
ret->Pixel( x, y, 1 ) = 0.5+ 0.5 * N.y;
|
|
ret->Pixel( x, y, 2 ) = 0.5+ 0.5 * N.z;
|
|
ret->Pixel( x, y, 3 ) = Pixel( x, y, 3 );
|
|
}
|
|
return ret;
|
|
}
|
|
|