void GUICanvas::buildImageElement(const CanvasElement& element)
{
assert(element.type == CanvasElementType::Image);
const ImageElementData& imageData = mImageData[element.dataId];
IMAGE_SPRITE_DESC desc;
desc.width = imageData.area.width;
desc.height = imageData.area.height;
desc.transparent = true;
desc.color = element.color;
Vector2I textureSize;
if (SpriteTexture::checkIsLoaded(imageData.texture))
{
desc.texture = imageData.texture.getInternalPtr();
textureSize.x = desc.texture->getWidth();
textureSize.y = desc.texture->getHeight();
}
Vector2I destSize(mLayoutData.area.width, mLayoutData.area.height);
desc.uvScale = ImageSprite::getTextureUVScale(textureSize, destSize, element.scaleMode);
element.imageSprite->update(desc, (UINT64)_getParentWidget());
}
// Called before the application loop begins. Load data here and
// not in the constructor so that common exceptions will be
// automatically caught.
void App::onInit() {
RenderDevice* rd = renderDevice;
Vector2 destSize(1024, 1024);
const Rect2D& dest = Rect2D::xywh(Vector2(0, 0), destSize);
Args args;
// args.appendToPreamble("#define KERNEL_RADIUS 9\nfloat gaussCoef[KERNEL_RADIUS] = float[KERNEL_RADIUS](0.00194372, 0.00535662, 0.01289581, 0.02712094, 0.04982645, 0.07996757, 0.11211578, 0.13731514, 0.14691596);");
rd->push2D(dest); {
args.setRect(dest);
LAUNCH_SHADER("apply.*", args);
} rd->pop2D();
// Or Equivalently:
//GaussianBlur::apply(renderDevice, Texture::createEmpty("test",1024,1024));
}
static void
gst_dewarp_update_map (GstDewarp * filter)
{
gdouble r1, r2, cx, cy;
gint x, y;
gint out_width, out_height;
if (filter->display_mode == GST_DEWARP_DISPLAY_PANORAMA) {
out_width = filter->out_width;
out_height = filter->out_height;
} else {
out_width = filter->out_width * 2;
out_height = filter->out_height / 2;
}
GST_DEBUG_OBJECT (filter,
"start update map out_width: %" G_GINT32_FORMAT " out height: %"
G_GINT32_FORMAT, out_width, out_height);
r1 = filter->in_width * filter->inner_radius;
r2 = filter->in_width * filter->outer_radius;
cx = filter->x_center * filter->in_width;
cy = filter->y_center * filter->in_height;
cv::Size destSize (out_width, out_height);
filter->map_x->create (destSize, CV_32FC1);
filter->map_y->create (destSize, CV_32FC1);
for (y = 0; y < out_height; y++) {
for (x = 0; x < out_width; x++) {
float r = ((float) (y) / (float) (out_height)) * (r2 - r1) + r1;
float theta = ((float) (x) / (float) (out_width)) * 2.0 * G_PI;
float xs = cx + r * sin (theta) * filter->remap_correction_x;
float ys = cy + r * cos (theta) * filter->remap_correction_y;
filter->map_x->at < float >(y, x) = xs;
filter->map_y->at < float >(y, x) = ys;
}
}
filter->need_map_update = FALSE;
GST_DEBUG_OBJECT (filter, "update map done");
}
// doDecreaseSize
//--------------------------------------------------------------------------
void MiniMapView::doDecreaseSize(int value)
{
iXY destSize(getViewRect().getSize());
if (value == -1) {
float dt = TimerInterface::getTimeSlice();
destSize -= scaleDelta * dt;
} else {
destSize -= value;
}
resize(destSize);
if (destSize < minMapSize) {
resize(iXY(minMapSize, minMapSize));
}
MiniMapInterface::setMapScale(getViewRect().getSize());
needScale = true;
scaleGroupWait = 0.0f;
} // end MiniMapView::doDecreaseSize
void TerrainBlock::_updateBaseTexture(bool writeToCache)
{
if ( !mBaseShader && !_initBaseShader() )
return;
// This can sometimes occur outside a begin/end scene.
const bool sceneBegun = GFX->canCurrentlyRender();
if ( !sceneBegun )
GFX->beginScene();
GFXDEBUGEVENT_SCOPE( TerrainBlock_UpdateBaseTexture, ColorI::GREEN );
PROFILE_SCOPE( TerrainBlock_UpdateBaseTexture );
GFXTransformSaver saver;
const U32 maxTextureSize = GFX->getCardProfiler()->queryProfile( "maxTextureSize", 1024 );
U32 baseTexSize = getNextPow2( mBaseTexSize );
baseTexSize = getMin( maxTextureSize, baseTexSize );
Point2I destSize( baseTexSize, baseTexSize );
// Setup geometry
GFXVertexBufferHandle<GFXVertexPT> vb;
{
F32 copyOffsetX = 2.0f * GFX->getFillConventionOffset() / (F32)destSize.x;
F32 copyOffsetY = 2.0f * GFX->getFillConventionOffset() / (F32)destSize.y;
GFXVertexPT points[4];
points[0].point = Point3F(1.0 - copyOffsetX, -1.0 + copyOffsetY, 0.0);
points[0].texCoord = Point2F(1.0, 1.0f);
points[1].point = Point3F(1.0 - copyOffsetX, 1.0 + copyOffsetY, 0.0);
points[1].texCoord = Point2F(1.0, 0.0f);
points[2].point = Point3F(-1.0 - copyOffsetX, -1.0 + copyOffsetY, 0.0);
points[2].texCoord = Point2F(0.0, 1.0f);
points[3].point = Point3F(-1.0 - copyOffsetX, 1.0 + copyOffsetY, 0.0);
points[3].texCoord = Point2F(0.0, 0.0f);
vb.set( GFX, 4, GFXBufferTypeVolatile );
GFXVertexPT *ptr = vb.lock();
if(ptr)
{
dMemcpy( ptr, points, sizeof(GFXVertexPT) * 4 );
vb.unlock();
}
}
GFXTexHandle blendTex;
// If the base texture is already a valid render target then
// use it to render to else we create one.
if ( mBaseTex.isValid() &&
mBaseTex->isRenderTarget() &&
mBaseTex->getFormat() == GFXFormatR8G8B8A8 &&
mBaseTex->getWidth() == destSize.x &&
mBaseTex->getHeight() == destSize.y )
blendTex = mBaseTex;
else
blendTex.set( destSize.x, destSize.y, GFXFormatR8G8B8A8, &GFXDefaultRenderTargetProfile, "" );
GFX->pushActiveRenderTarget();
// Set our shader stuff
GFX->setShader( mBaseShader );
GFX->setShaderConstBuffer( mBaseShaderConsts );
GFX->setStateBlock( mBaseShaderSB );
GFX->setVertexBuffer( vb );
mBaseTarget->attachTexture( GFXTextureTarget::Color0, blendTex );
GFX->setActiveRenderTarget( mBaseTarget );
GFX->clear( GFXClearTarget, ColorI(0,0,0,255), 1.0f, 0 );
GFX->setTexture( 0, mLayerTex );
mBaseShaderConsts->setSafe( mBaseLayerSizeConst, (F32)mLayerTex->getWidth() );
for ( U32 i=0; i < mBaseTextures.size(); i++ )
{
GFXTextureObject *tex = mBaseTextures[i];
if ( !tex )
continue;
GFX->setTexture( 1, tex );
F32 baseSize = mFile->mMaterials[i]->getDiffuseSize();
F32 scale = 1.0f;
if ( !mIsZero( baseSize ) )
scale = getWorldBlockSize() / baseSize;
// A mistake early in development means that texture
// coords are not flipped correctly. To compensate
// we flip the y scale here.
mBaseShaderConsts->setSafe( mBaseTexScaleConst, Point2F( scale, -scale ) );
mBaseShaderConsts->setSafe( mBaseTexIdConst, (F32)i );
GFX->drawPrimitive( GFXTriangleStrip, 0, 2 );
}
mBaseTarget->resolve();
GFX->setShader( NULL );
//GFX->setStateBlock( NULL ); // WHY NOT?
GFX->setShaderConstBuffer( NULL );
GFX->setVertexBuffer( NULL );
GFX->popActiveRenderTarget();
// End it if we begun it... Yeehaw!
if ( !sceneBegun )
GFX->endScene();
/// Do we cache this sucker?
if (mBaseTexFormat == NONE || !writeToCache)
{
// We didn't cache the result, so set the base texture
// to the render target we updated. This should be good
// for realtime painting cases.
mBaseTex = blendTex;
}
else if (mBaseTexFormat == DDS)
{
String cachePath = _getBaseTexCacheFileName();
FileStream fs;
if ( fs.open( _getBaseTexCacheFileName(), Torque::FS::File::Write ) )
{
// Read back the render target, dxt compress it, and write it to disk.
GBitmap blendBmp( destSize.x, destSize.y, false, GFXFormatR8G8B8A8 );
blendTex.copyToBmp( &blendBmp );
/*
// Test code for dumping uncompressed bitmap to disk.
{
FileStream fs;
if ( fs.open( "./basetex.png", Torque::FS::File::Write ) )
{
blendBmp.writeBitmap( "png", fs );
fs.close();
}
}
*/
blendBmp.extrudeMipLevels();
DDSFile *blendDDS = DDSFile::createDDSFileFromGBitmap( &blendBmp );
DDSUtil::squishDDS( blendDDS, GFXFormatDXT1 );
// Write result to file stream
blendDDS->write( fs );
delete blendDDS;
}
fs.close();
}
else
{
FileStream stream;
if (!stream.open(_getBaseTexCacheFileName(), Torque::FS::File::Write))
{
mBaseTex = blendTex;
return;
}
GBitmap bitmap(blendTex->getWidth(), blendTex->getHeight(), false, GFXFormatR8G8B8);
blendTex->copyToBmp(&bitmap);
bitmap.writeBitmap(formatToExtension(mBaseTexFormat), stream);
}
}
int VsReader::getData( VsDataset* dataSet,
void* data,
// Use these variables for adjusting
// the read memory space.
std::string indexOrder, // Index ordering
int components, // Index for a component
int* srcMins, // start locations
int* srcCounts, // number of entries
int* srcStrides, // stride in memory
// Use these variables for adjusting
// the write memory space.
int mdims, // spatial dims (rank)
int* destSizes, // overall memory size
int* destMins, // start locations
int* destCounts, // number of entries
int* destStrides ) const // stride in memory
{
// components = -2 No component array (i.e. scalar variable)
// components = -1 Component array present but read all values.
// (i.e. vector variable or point coordinates)
// component >= 0 Component array present read single value at that index.
if (dataSet == NULL) {
VsLog::debugLog() << __CLASS__ << __FUNCTION__ << " " << __LINE__ << " "
<< "Requested dataset is null?" << std::endl;
return -1;
}
if (data == NULL) {
VsLog::debugLog() << __CLASS__ << __FUNCTION__ << " " << __LINE__ << " "
<< "Data storage is null?" << std::endl;
return -1;
}
int err = 0;
// No index ordering info so read all data.
if (indexOrder.length() == 0)
{
err = H5Dread(dataSet->getId(), dataSet->getType(),
H5S_ALL, H5S_ALL, H5P_DEFAULT, data);
if (err < 0) {
VsLog::debugLog() << __CLASS__ << __FUNCTION__ << " " << __LINE__ << " "
<< "Error " << err
<< " in reading variable " << dataSet->getFullName()
<< "." << std::endl;
return err;
}
}
// mins, counts, and/or strides so hyperslab.
else
{
hid_t dataspace = H5Dget_space(dataSet->getId());
int ndims = H5Sget_simple_extent_ndims(dataspace);
if (ndims == 0) {
VsLog::debugLog() << __CLASS__ << __FUNCTION__ << " " << __LINE__ << " "
<< "Unable to load dimensions for variable."
<< "Returning -1." << std::endl;
return -1;
}
std::vector<hsize_t> dims(ndims);
int ndim = H5Sget_simple_extent_dims(dataspace, &(dims[0]), NULL);
if( ndim != ndims ) {
VsLog::debugLog() << __CLASS__ << __FUNCTION__ << " " << __LINE__ << " "
<< "Data dimensions not match. " << std::endl;
return -1;
}
VsLog::debugLog() << __CLASS__ << __FUNCTION__ << " " << __LINE__ << " "
<< "about to set up arguments." << std::endl;
std::vector<hsize_t> count(ndims);
std::vector<hsize_t> start(ndims);
std::vector<hsize_t> stride(ndims);
// FORTRAN ordering.
if((indexOrder == VsSchema::compMinorFKey) ||
(indexOrder == VsSchema::compMajorFKey))
{
// No components - [iz][iy][ix]
if( components == -2 )
{
for (unsigned int i = 0; i< (unsigned int)ndims; i++)
{
// Flip the ordering of the input.
int base = ndims - 1;
start[1] = (hsize_t) srcMins[base-i];
count[1] = (hsize_t) srcCounts[base-i];
stride[1] = (hsize_t) srcStrides[base-i];
VsLog::debugLog()
<< __CLASS__ << __FUNCTION__ << " " << __LINE__ << " "
<< "For i = " << i
<< ", start = " << start[i]
<< ", count = " << count[i]
<< ", stride = " << stride[i]
<< std::endl;
}
}
else if(indexOrder == VsSchema::compMajorFKey)
{
// Multiple components - [ic][iz][iy][ix] compMajorF
for (unsigned int i = 0; i< (unsigned int)ndims-1; i++)
{
// Flip the ordering of the input.
int base = ndims - 1;
start[i+1] = (hsize_t) srcMins[base-i];
count[i+1] = (hsize_t) srcCounts[base-i];
stride[i+1] = (hsize_t) srcStrides[base-i];
VsLog::debugLog()
<< __CLASS__ << __FUNCTION__ << " " << __LINE__ << " "
<< "For i = " << i
<< ", start = " << start[i+1]
<< ", count = " << count[i+1]
<< ", stride = " << stride[i+1]
<< std::endl;
}
// Components present but read all
if( components < 0 )
{
start[0] = 0;
count[0] = dims[ndims-1];
stride[0] = 1;
}
else // Components present but read a single value
{
start[0] = components;
count[0] = 1;
stride[0] = 1;
}
}
else //if( indexOrder == VsSchema::compMinorFKey )
{
// Multiple components - [iz][iy][ix][ic] compMinorF
for (unsigned int i = 0; i< (unsigned int)ndims-1; i++)
{
// Flip the ordering of the input.
int base = ndims - 1;
start[i] = (hsize_t) srcMins[base-i];
count[i] = (hsize_t) srcCounts[base-i];
stride[i] = (hsize_t) srcStrides[base-i];
VsLog::debugLog()
<< __CLASS__ << __FUNCTION__ << " " << __LINE__ << " "
<< "For i = " << i
<< ", start = " << start[i]
<< ", count = " << count[i]
<< ", stride = " << stride[i]
<< std::endl;
}
// Components present but read all
if( components < 0 )
{
start[ndims-1] = 0;
count[ndims-1] = dims[ndims-1];
stride[ndims-1] = 1;
}
else // Components present but read a single value
{
start[ndims-1] = components;
count[ndims-1] = 1;
stride[ndims-1] = 1;
}
}
}
// C ordering.
else //if((indexOrder == VsSchema::compMinorCKey) ||
// (indexOrder == VsSchema::compMajorCKey))
{
if( components == -2 )
{
// No components - [ix][iy][iz]
for (unsigned int i = 0; i< (unsigned int)ndims; i++)
{
start[i] = (hsize_t) srcMins[i];
count[i] = (hsize_t) srcCounts[i];
stride[i] = (hsize_t) srcStrides[i];
VsLog::debugLog()
<< __CLASS__ << __FUNCTION__ << " " << __LINE__ << " "
<< "For i = " << i
<< ", start = " << start[i]
<< ", count = " << count[i]
<< ", stride = " << stride[i]
<< std::endl;
}
}
else if(indexOrder == VsSchema::compMajorCKey)
{
// Multiple components - [ic][ix][iy][iz] compMajorC
for (unsigned int i = 0; i< (unsigned int)ndims-1; i++)
{
start[i+1] = (hsize_t) srcMins[i];
count[i+1] = (hsize_t) srcCounts[i];
stride[i+1] = (hsize_t) srcStrides[i];
VsLog::debugLog()
<< __CLASS__ << __FUNCTION__ << " " << __LINE__ << " "
<< "For i = " << i
<< ", start = " << start[i+1]
<< ", count = " << count[i+1]
<< ", stride = " << stride[i+1]
<< std::endl;
}
// Components present but read all
if( components < 0 )
{
start[0] = 0;
count[0] = dims[ndims-1];
stride[0] = 1;
}
else // Components present but read a single value
{
start[0] = components;
count[0] = 1;
stride[0] = 1;
}
}
else if(indexOrder == VsSchema::compMinorCKey)
{
// Multiple components - [ix][iy][iz][ic] compMinorC
for (unsigned int i = 0; i< (unsigned int)ndims-1; i++)
{
start[i] = (hsize_t) srcMins[i];
count[i] = (hsize_t) srcCounts[i];
stride[i] = (hsize_t) srcStrides[i];
VsLog::debugLog()
<< __CLASS__ << __FUNCTION__ << " " << __LINE__ << " "
<< "For i = " << i
<< ", start = " << start[i]
<< ", count = " << count[i]
<< ", stride = " << stride[i]
<< std::endl;
}
// Components present but read all
if( components < 0 )
{
start[ndims-1] = 0;
count[ndims-1] = dims[ndims-1];
stride[ndims-1] = 1;
}
else // Components present but read a single value
{
start[ndims-1] = components;
count[ndims-1] = 1;
stride[ndims-1] = 1;
}
}
}
// Select subset of the data
if( srcMins )
err = H5Sselect_hyperslab(dataspace, H5S_SELECT_SET,
&(start[0]), &(stride[0]), &(count[0]), NULL);
VsLog::debugLog() << __CLASS__ << __FUNCTION__ << " " << __LINE__ << " "
<< "After selecting the hyperslab, err is " << err
<< std::endl;
// Create memory space for the data
hid_t memspace;
std::vector<hsize_t> destSize(ndims);
std::vector<hsize_t> destCount(ndims);
std::vector<hsize_t> destStart(ndims);
std::vector<hsize_t> destStride(ndims);
if( mdims == 0 )
memspace = H5Screate_simple(ndims, &(count[0]), NULL);
else
{
for( int i=0; i<mdims; ++i )
{
destSize[i] = (hsize_t) destSizes[i];
destStart[i] = (hsize_t) destMins[i];
destCount[i] = (hsize_t) destCounts[i];
destStride[i] = (hsize_t) destStrides[i];
}
memspace = H5Screate_simple(mdims, &(destSize[0]), NULL);
H5Sselect_hyperslab(memspace, H5S_SELECT_SET,
&(destStart[0]), &(destStride[0]), &(destCount[0]),
NULL);
}
// Read data
err = H5Dread(dataSet->getId(), dataSet->getType(), memspace, dataspace,
H5P_DEFAULT, data);
if (err < 0) {
VsLog::debugLog() << __CLASS__ << __FUNCTION__ << " " << __LINE__ << " "
<< ": error " << err
<< " in reading dataset." << std::endl;
}
err = H5Sclose(memspace);
err = H5Sclose(dataspace);
}
VsLog::debugLog() << __CLASS__ << __FUNCTION__ << " " << __LINE__ << " "
<< "Returning " << err << "." << std::endl;
return err;
}
// doIncreaseSize
//--------------------------------------------------------------------------
void MiniMapView::doIncreaseSize(int value)
{
iXY destSize(getViewRect().getSize());
if (value == -1) {
float dt = TimerInterface::getTimeSlice();
destSize += scaleDelta * dt;
} else {
destSize += value;
}
//resize(destSize);
//deltaSize += deltaAmount;
if (destSize > maxMapSize) {
destSize = maxMapSize;
}
// Check the validity of the X dimension.
if ((min.x + destSize.x) >= SCREEN_XPIX) {
int xOffset = min.x + destSize.x - SCREEN_XPIX;
int destXPos = min.x - xOffset;
if (destXPos < 0) {
moveTo(0, min.y);
} else {
moveTo(destXPos, min.y);
}
}
// Check the validity of the Y dimension.
if ((min.y + destSize.y) >= SCREEN_YPIX) {
int yOffset = min.y + destSize.y - SCREEN_YPIX;
int destYPos = min.y - yOffset;
if (destYPos < 0) {
moveTo(min.x, 0);
} else {
moveTo(min.x, destYPos);
}
}
// Resize the x dimension.
if (destSize.x > getViewRect().getSize().x) {
if (destSize.x > maxMapSize) {
resize(iXY(maxMapSize, getViewRect().getSize().y));
} else {
resize(iXY(destSize.x, getViewRect().getSize().y));
}
}
// Resize the y dimension.
if (destSize.y > getViewRect().getSize().y) {
if (destSize.x > maxMapSize) {
resize(iXY(getViewRect().getSize().x, maxMapSize));
} else {
resize(iXY(getViewRect().getSize().x, destSize.x));
}
}
MiniMapInterface::setMapScale(getViewRect().getSize());
needScale = true;
scaleGroupWait = 0.0f;
} // end MiniMapView::doIncreaseSize
