// Console Functions
void loadHeightMap(SimObject *obj, S32 argc, const char *argv[])
{
GBitmap *bmp = dynamic_cast<GBitmap*>(Link.ResourceManager->loadInstance(argv[1]));
if(bmp != NULL)
{
terrainBuilder->height = (bmp->getHeight() / 2) * 2;
terrainBuilder->width = (bmp->getWidth() / 2) * 2;
terrainBuilder->heightMap = new F32[terrainBuilder->height * terrainBuilder->width];
for(U32 y = 0; y < terrainBuilder->height; y++)
{
for(U32 x = 0; x < terrainBuilder->width; x++)
{
ColorI heightSample;
bmp->getColor(x, y, heightSample);
terrainBuilder->heightMap[(y * terrainBuilder->width) + x] = ((F32)heightSample.red) * 0.1f;
}
}
terrainBuilder->rebuild();
refresh();
}
}
S32 GuiControlProfile::constructBitmapArray()
{
if(mBitmapArrayRects.size())
return mBitmapArrayRects.size();
if( mTextureObject.isNull() )
{
if ( !mBitmapName || !mBitmapName[0] || !mTextureObject.set( mBitmapName, &GFXDefaultPersistentProfile, avar("%s() - mTextureObject (line %d)", __FUNCTION__, __LINE__) ))
return 0;
}
GBitmap *bmp = mTextureObject->getBitmap();
//get the separator color
ColorI sepColor;
if ( !bmp || !bmp->getColor( 0, 0, sepColor ) )
{
Con::errorf("Failed to create bitmap array from %s for profile %s - couldn't ascertain seperator color!", mBitmapName, getName());
AssertFatal( false, avar("Failed to create bitmap array from %s for profile %s - couldn't ascertain seperator color!", mBitmapName, getName()));
return 0;
}
//now loop through all the scroll pieces, and find the bounding rectangle for each piece in each state
S32 curY = 0;
// ascertain the height of this row...
ColorI color;
mBitmapArrayRects.clear();
while(curY < bmp->getHeight())
{
// skip any sep colors
bmp->getColor( 0, curY, color);
if(color == sepColor)
{
curY++;
continue;
}
// ok, process left to right, grabbing bitmaps as we go...
S32 curX = 0;
while(curX < bmp->getWidth())
{
bmp->getColor(curX, curY, color);
if(color == sepColor)
{
curX++;
continue;
}
S32 startX = curX;
while(curX < bmp->getWidth())
{
bmp->getColor(curX, curY, color);
if(color == sepColor)
break;
curX++;
}
S32 stepY = curY;
while(stepY < bmp->getHeight())
{
bmp->getColor(startX, stepY, color);
if(color == sepColor)
break;
stepY++;
}
mBitmapArrayRects.push_back(RectI(startX, curY, curX - startX, stepY - curY));
}
// ok, now skip to the next separation color on column 0
while(curY < bmp->getHeight())
{
bmp->getColor(0, curY, color);
if(color == sepColor)
break;
curY++;
}
}
return mBitmapArrayRects.size();
}
Point2I GuiColorPickerCtrl::findColor(const ColorF & color, const Point2I& offset, const Point2I& resolution, GBitmap& bmp)
{
RectI rect;
Point2I ext = getExtent();
if (mDisplayMode != pDropperBackground)
{
ext.x -= 3;
ext.y -= 2;
rect = RectI(Point2I(1, 1), ext);
}
else
{
rect = RectI(Point2I(0, 0), ext);
}
Point2I closestPos(-1, -1);
/* Debugging
char filename[256];
dSprintf( filename, 256, "%s.%s", "colorPickerTest", "png" );
// Open up the file on disk.
FileStream fs;
if ( !fs.open( filename, Torque::FS::File::Write ) )
Con::errorf( "GuiObjectView::saveAsImage() - Failed to open output file '%s'!", filename );
else
{
// Write it and close.
bmp.writeBitmap( "png", fs );
fs.close();
}
*/
ColorI tmp;
U32 buf_x;
U32 buf_y;
ColorF curColor;
F32 val(10000.0f);
F32 closestVal(10000.0f);
bool closestSet = false;
for (S32 x = rect.point.x; x <= rect.extent.x; x++)
{
for (S32 y = rect.point.y; y <= rect.extent.y; y++)
{
buf_x = offset.x + x + 1;
buf_y = (resolution.y - (offset.y + y + 1));
buf_y = resolution.y - buf_y;
//Get the color at that position
bmp.getColor(buf_x, buf_y, tmp);
curColor = (ColorF)tmp;
//Evaluate how close the color is to our desired color
val = mFabs(color.red - curColor.red) + mFabs(color.green - curColor.green) + mFabs(color.blue - curColor.blue);
if (!closestSet)
{
closestVal = val;
closestPos.set(x, y);
closestSet = true;
}
else if (val < closestVal)
{
closestVal = val;
closestPos.set(x, y);
}
}
}
return closestPos;
}
void blInteriorProxy::addToShadowVolume(ShadowVolumeBSP * shadowVolume, LightInfo * light, S32 level)
{
if(light->getType() != LightInfo::Vector)
return;
ColorF ambient = light->getAmbient();
bool shadowedTree = true;
InteriorInstance* interior = dynamic_cast<InteriorInstance*>(getObject());
if (!interior)
return;
Resource<InteriorResource> mInteriorRes = interior->getResource();
// check if just getting shadow detail
if(level == SceneLighting::SHADOW_DETAIL)
{
shadowedTree = false;
level = mInteriorRes->getNumDetailLevels() - 1;
}
Interior * detail = mInteriorRes->getDetailLevel(level);
bool hasAlarm = detail->hasAlarmState();
// make sure surfaces do not get processed more than once
BitVector surfaceProcessed;
surfaceProcessed.setSize(detail->mSurfaces.size());
surfaceProcessed.clear();
ColorI color = light->getAmbient();
// go through the zones of the interior and grab outside visible surfaces
for(U32 i = 0; i < detail->getNumZones(); i++)
{
Interior::Zone & zone = detail->mZones[i];
for(U32 j = 0; j < zone.surfaceCount; j++)
{
U32 surfaceIndex = detail->mZoneSurfaces[zone.surfaceStart + j];
// dont reprocess a surface
if(surfaceProcessed.test(surfaceIndex))
continue;
surfaceProcessed.set(surfaceIndex);
Interior::Surface & surface = detail->mSurfaces[surfaceIndex];
// outside visible?
if(!(surface.surfaceFlags & Interior::SurfaceOutsideVisible))
continue;
// good surface?
PlaneF plane = detail->getPlane(surface.planeIndex);
if(Interior::planeIsFlipped(surface.planeIndex))
plane.neg();
// project the plane
PlaneF projPlane;
mTransformPlane(interior->getTransform(), interior->getScale(), plane, &projPlane);
// fill with ambient? (need to do here, because surface will not be
// added to the SVBSP tree)
F32 dot = mDot(projPlane, light->getDirection());
if(dot > -gParellelVectorThresh)// && !(GFX->getPixelShaderVersion() > 0.0) )
{
if(shadowedTree)
{
// alarm lighting
GFXTexHandle normHandle = gInteriorLMManager.duplicateBaseLightmap(detail->getLMHandle(), interior->getLMHandle(), detail->getNormalLMapIndex(surfaceIndex));
GFXTexHandle alarmHandle;
GBitmap * normLightmap = normHandle->getBitmap();
GBitmap * alarmLightmap = 0;
// check if they share the lightmap
if(hasAlarm)
{
if(detail->getNormalLMapIndex(surfaceIndex) != detail->getAlarmLMapIndex(surfaceIndex))
{
alarmHandle = gInteriorLMManager.duplicateBaseLightmap(detail->getLMHandle(), interior->getLMHandle(), detail->getAlarmLMapIndex(surfaceIndex));
alarmLightmap = alarmHandle->getBitmap();
}
}
//
// Support for interior light map border sizes.
//
U32 xlen, ylen, xoff, yoff;
U32 lmborder = detail->getLightMapBorderSize();
xlen = surface.mapSizeX + (lmborder * 2);
ylen = surface.mapSizeY + (lmborder * 2);
xoff = surface.mapOffsetX - lmborder;
yoff = surface.mapOffsetY - lmborder;
// attemp to light normal and alarm lighting
for(U32 c = 0; c < 2; c++)
{
GBitmap * lightmap = (c == 0) ? normLightmap : alarmLightmap;
if(!lightmap)
continue;
// fill it
for(U32 y = 0; y < ylen; y++)
{
for(U32 x = 0; x < xlen; x++)
{
ColorI outColor(255, 0, 0, 255);
#ifndef SET_COLORS
ColorI lmColor(0, 0, 0, 255);
lightmap->getColor(xoff + x, yoff + y, lmColor);
U32 _r = static_cast<U32>( color.red ) + static_cast<U32>( lmColor.red );
U32 _g = static_cast<U32>( color.green ) + static_cast<U32>( lmColor.green );
U32 _b = static_cast<U32>( color.blue ) + static_cast<U32>( lmColor.blue );
outColor.red = mClamp(_r, 0, 255);
outColor.green = mClamp(_g, 0, 255);
outColor.blue = mClamp(_b, 0, 255);
#endif
lightmap->setColor(xoff + x, yoff + y, outColor);
}
}
}
}
continue;
}
ShadowVolumeBSP::SVPoly * poly = buildInteriorPoly(shadowVolume, detail,
surfaceIndex, light, shadowedTree);
// insert it into the SVBSP tree
shadowVolume->insertPoly(poly);
}
}
}
