/*
================
idLight::ReadFromSnapshot
================
*/
void idLight::ReadFromSnapshot( const idBitMsgDelta &msg ) {
idVec4 shaderColor;
int oldCurrentLevel = currentLevel;
idVec3 oldBaseColor = baseColor;
GetPhysics()->ReadFromSnapshot( msg );
ReadBindFromSnapshot( msg );
currentLevel = msg.ReadByte();
if ( currentLevel != oldCurrentLevel ) {
// need to call On/Off for flickering lights to start/stop the sound
// while doing it this way rather than through events, the flickering is out of sync between clients
// but at least there is no question about saving the event and having them happening globally in the world
if ( currentLevel ) {
On();
} else {
Off();
}
}
UnpackColor( msg.ReadLong(), baseColor );
// lightParentEntityNum = msg.ReadBits( GENTITYNUM_BITS );
/* // only helps prediction
UnpackColor( msg.ReadLong(), fadeFrom );
UnpackColor( msg.ReadLong(), fadeTo );
fadeStart = msg.ReadLong();
fadeEnd = msg.ReadLong();
*/
// FIXME: read renderLight.shader
renderLight.lightRadius[0] = msg.ReadFloat( 5, 10 );
renderLight.lightRadius[1] = msg.ReadFloat( 5, 10 );
renderLight.lightRadius[2] = msg.ReadFloat( 5, 10 );
UnpackColor( msg.ReadLong(), shaderColor );
renderLight.shaderParms[SHADERPARM_RED] = shaderColor[0];
renderLight.shaderParms[SHADERPARM_GREEN] = shaderColor[1];
renderLight.shaderParms[SHADERPARM_BLUE] = shaderColor[2];
renderLight.shaderParms[SHADERPARM_ALPHA] = shaderColor[3];
renderLight.shaderParms[SHADERPARM_TIMESCALE] = msg.ReadFloat( 5, 10 );
renderLight.shaderParms[SHADERPARM_TIMEOFFSET] = msg.ReadLong();
//renderLight.shaderParms[SHADERPARM_DIVERSITY] = msg.ReadFloat();
renderLight.shaderParms[SHADERPARM_MODE] = msg.ReadShort();
ReadColorFromSnapshot( msg );
if ( msg.HasChanged() ) {
if ( ( currentLevel != oldCurrentLevel ) || ( baseColor != oldBaseColor ) ) {
SetLightLevel();
} else {
PresentLightDefChange();
PresentModelDefChange();
}
}
}
MALIB_API COLOR::COLOR(uint c, PIXELFORMAT format)
{
uchar red = 0;
uchar green = 0;
uchar blue = 0;
uchar alpha = 0;
UnpackColor(c, &red, &green, &blue, &alpha, format);
this->r = float(red) / 255.0f;
this->g = float(green) / 255.0f;
this->b = float(blue) / 255.0f;
this->a = float(alpha) / 255.0f;
}
static LUA_DECLARE( drawBitmap )
{
Bitmap *src;
double x, y;
double width, height;
eDrawOpType drawOp;
LUA_ARGS_BEGIN;
argStream.ReadClass( src, LUACLASS_BITMAP );
argStream.ReadNumber( x );
argStream.ReadNumber( y );
argStream.ReadNumber( width, 0 );
argStream.ReadNumber( height, 0 );
argStream.ReadEnumString( drawOp, DRAWOP_MODULATE );
LUA_ARGS_END;
// Establish draw operation scales.
double xScale, yScale;
if ( width == 0 )
{
xScale = 1.0f;
width = src->GetWidth();
}
else
xScale = width / (float)src->GetWidth();
if ( height == 0 )
{
yScale = 1.0f;
height = src->GetHeight();
}
else
yScale = height / (float)src->GetHeight();
// For now; later we may support flipping of images!
LUA_CHECK( width > 0 && height > 0 );
Bitmap *map = (Bitmap*)lua_getmethodtrans( L );
// Cache the bitmap types
Bitmap::eDataType srcDataType = src->m_dataType;
Bitmap::eDataType dstDataType = map->m_dataType;
// We cannot draw us to ourselves.
LUA_CHECK( map != src );
unsigned int srcWidth = src->GetWidth();
unsigned int srcHeight = src->GetHeight();
unsigned int dstWidth = map->GetWidth();
unsigned int dstHeight = map->GetHeight();
// Make sure the draw operations target valid zones
double endTargetX = x + width;
double endTargetY = y + height;
// Is the draw zone clipping out of the target zone?
// Do not render then.
LUA_CHECK( endTargetX > 0 && endTargetY > 0 &&
x < dstWidth && y < dstHeight );
// Draw it!
unsigned int ySrcPos = 0;
for ( double yPos = y; yPos < endTargetY; yPos += yScale, ySrcPos++ )
{
unsigned int xSrcPos = 0;
for ( double xPos = x; xPos < endTargetX; xPos += xScale, xSrcPos++ )
{
unsigned int pixelDstX = (unsigned int)xPos;
unsigned int pixelDstY = (unsigned int)yPos;
unsigned int pixelSrcX = (unsigned int)xSrcPos;
unsigned int pixelSrcY = (unsigned int)ySrcPos;
// Unpack the colors
double srcRed;
double srcGreen;
double srcBlue;
double srcAlpha;
UnpackColor( src->m_data, pixelSrcX, pixelSrcY, srcWidth, srcDataType, srcRed, srcGreen, srcBlue, srcAlpha );
double dstRed;
double dstGreen;
double dstBlue;
double dstAlpha;
UnpackColor( map->m_data, pixelDstX, pixelDstY, dstWidth, dstDataType, dstRed, dstGreen, dstBlue, dstAlpha );
// TODO: allow blendfactor changing.
// Currently it is SRC_ALPHA, ONE_MINUS_SRC_ALPHA
double resRed;
double resGreen;
double resBlue;
double resAlpha;
switch( drawOp )
{
case DRAWOP_MODULATE:
// Alpha blend the bitmaps together
resRed = SharedUtil::Min <double> ( 1.0f, ( srcRed * srcAlpha ) + ( dstRed * (1 - srcAlpha) ) );
resGreen = SharedUtil::Min <double> ( 1.0f, ( srcGreen * srcAlpha ) + ( dstGreen * (1 - srcAlpha) ) );
resBlue = SharedUtil::Min <double> ( 1.0f, ( srcBlue * srcAlpha ) + ( dstBlue * (1 - srcAlpha) ) );
resAlpha = SharedUtil::Min <double> ( 1.0f, ( srcAlpha * srcAlpha ) + ( dstAlpha * (1 - srcAlpha) ) );
break;
case DRAWOP_WRITE:
// We just copy data from bitmap src to dst
resRed = srcRed;
resGreen = srcGreen;
resBlue = srcBlue;
resAlpha = srcAlpha;
break;
default:
// Unknown operation.
resRed = 1.0f;
resGreen = 1.0f;
resBlue = 1.0f;
resAlpha = 1.0f;
break;
}
// Pack the colors again.
PackColor( map->m_data, pixelDstX, pixelDstY, dstWidth, dstDataType, resRed, resGreen, resBlue, resAlpha );
}
}
lua_pushboolean( L, true );
return 1;
}
