DEF_GPUTEST_FOR_NATIVE_CONTEXT(SkImage_newTextureImage, reporter, context, glContext) {
GrContextFactory otherFactory;
GrContextFactory::ContextInfo otherContextInfo =
otherFactory.getContextInfo(GrContextFactory::kNative_GLContextType);
glContext->makeCurrent();
std::function<SkImage*()> imageFactories[] = {
create_image,
create_codec_image,
create_data_image,
// Create an image from a picture.
create_picture_image,
// Create a texture image.
[context] { return create_gpu_image(context); },
// Create a texture image in a another GrContext.
[glContext, otherContextInfo] {
otherContextInfo.fGLContext->makeCurrent();
SkImage* otherContextImage = create_gpu_image(otherContextInfo.fGrContext);
glContext->makeCurrent();
return otherContextImage;
}
};
for (auto factory : imageFactories) {
SkAutoTUnref<SkImage> image(factory());
if (!image) {
ERRORF(reporter, "Error creating image.");
continue;
}
GrTexture* origTexture = as_IB(image)->peekTexture();
SkAutoTUnref<SkImage> texImage(image->newTextureImage(context));
if (!texImage) {
// We execpt to fail if image comes from a different GrContext.
if (!origTexture || origTexture->getContext() == context) {
ERRORF(reporter, "newTextureImage failed.");
}
continue;
}
GrTexture* copyTexture = as_IB(texImage)->peekTexture();
if (!copyTexture) {
ERRORF(reporter, "newTextureImage returned non-texture image.");
continue;
}
if (origTexture) {
if (origTexture != copyTexture) {
ERRORF(reporter, "newTextureImage made unnecessary texture copy.");
}
}
if (image->width() != texImage->width() || image->height() != texImage->height()) {
ERRORF(reporter, "newTextureImage changed the image size.");
}
if (image->isOpaque() != texImage->isOpaque()) {
ERRORF(reporter, "newTextureImage changed image opaqueness.");
}
}
}
void TextRenderer::createFontTexture()
{
QImage texImage( ":/icons/droidsansmono256.png", "PNG" );
QImage GL_formatted_image = QGLWidget::convertToGLFormat(texImage);
glGenTextures( 1, &m_fontTextureGLuint[0] );
glBindTexture( GL_TEXTURE_2D, m_fontTextureGLuint[0] );
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, texImage.width(), texImage.height(), 0, GL_RGBA, GL_UNSIGNED_BYTE, GL_formatted_image.bits() );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
}
GLuint Global::hollowSpriteTexture()
{
if (m_hollowSpriteTexture)
return m_hollowSpriteTexture;
glGenTextures( 1, &m_hollowSpriteTexture );
//----------------------------------------
//--- hollow circle sprite ---
int texsize = 64;
int t2 = texsize/2;
QRadialGradient rg(t2, t2, t2-1, t2, t2);
rg.setColorAt(0.0, Qt::white);
rg.setColorAt(1.0, Qt::black);
QImage texImage(texsize, texsize, QImage::Format_ARGB32);
texImage.fill(0);
QPainter p(&texImage);
p.setBrush(QBrush(rg));
p.setPen(Qt::transparent);
p.drawEllipse(0, 0, texsize, texsize);
uchar *thetexture = new uchar[2*texsize*texsize];
const uchar *bits = texImage.bits();
//const uchar *bits = info.bits();
for(int i=0; i<texsize*texsize; i++)
{
uchar lum = 255;
float a = (float)bits[4*i+2]/255.0f;
a = 1-a;
if (a < 0.8 || a >= 1.0)
{
a = 0;
lum = 0;
}
else
{
lum *= 1-fabs(a-0.8f)/0.2f;
a = 0.9f;
}
a *= 255;
thetexture[2*i] = lum;
thetexture[2*i+1] = a;
}
//----------------------------------------
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, m_hollowSpriteTexture);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA,
texsize, texsize, 0,
GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
thetexture);
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
delete [] thetexture;
return m_hollowSpriteTexture;
}
void writeFrames(const Kinect::FrameSource::IntrinsicParameters& ip,const Kinect::FrameBuffer& color,const Kinect::MeshBuffer& mesh,const char* lwoFileName)
{
/* Create the texture file name: */
std::string textureFileName(lwoFileName,Misc::getExtension(lwoFileName));
textureFileName.append("-color.png");
/* Write the color frame as a texture image: */
{
Images::RGBImage texImage(color.getSize(0),color.getSize(1));
Images::RGBImage::Color* tiPtr=texImage.modifyPixels();
const unsigned char* cfPtr=reinterpret_cast<const unsigned char*>(color.getBuffer());
for(int y=0;y<color.getSize(1);++y)
for(int x=0;x<color.getSize(0);++x,++tiPtr,cfPtr+=3)
*tiPtr=Images::RGBImage::Color(cfPtr);
Images::writeImageFile(texImage,textureFileName.c_str());
}
/* Open the LWO file: */
IO::FilePtr lwoFile=IO::openFile(lwoFileName,IO::File::WriteOnly);
lwoFile->setEndianness(Misc::BigEndian);
/* Create the LWO file structure via the FORM chunk: */
{
IFFChunkWriter form(lwoFile,"FORM");
form.write<char>("LWO2",4);
/* Create the TAGS chunk: */
{
IFFChunkWriter tags(&form,"TAGS");
tags.writeString("ColorImage");
tags.writeChunk();
}
/* Create the LAYR chunk: */
{
IFFChunkWriter layr(&form,"LAYR");
layr.write<Misc::UInt16>(0U);
layr.write<Misc::UInt16>(0x0U);
for(int i=0;i<3;++i)
layr.write<Misc::Float32>(0.0f);
layr.writeString("DepthImage");
layr.writeChunk();
}
/* Create an index map for all vertices to omit unused vertices: */
unsigned int* indices=new unsigned int[mesh.numVertices];
for(unsigned int i=0;i<mesh.numVertices;++i)
indices[i]=~0x0U;
unsigned int numUsedVertices=0;
/* Create the PNTS, BBOX and VMAP chunks in one go: */
{
typedef Kinect::FrameSource::IntrinsicParameters::PTransform PTransform;
typedef PTransform::Point Point;
typedef Geometry::Box<Point::Scalar,3> Box;
IFFChunkWriter bbox(&form,"BBOX");
IFFChunkWriter pnts(&form,"PNTS");
IFFChunkWriter vmap(&form,"VMAP");
/* Write the VMAP header: */
vmap.write<char>("TXUV",4);
vmap.write<Misc::UInt16>(2U);
vmap.writeString("ColorImageUV");
/* Process all triangle vertices: */
Box pBox=Box::empty;
const Kinect::MeshBuffer::Vertex* vertices=mesh.getVertices();
const Kinect::MeshBuffer::Index* tiPtr=mesh.getTriangleIndices();
for(unsigned int i=0;i<mesh.numTriangles*3;++i,++tiPtr)
{
/* Check if the triangle vertex doesn't already have an index: */
if(indices[*tiPtr]==~0x0U)
{
/* Assign an index to the triangle vertex: */
indices[*tiPtr]=numUsedVertices;
/* Transform the mesh vertex to camera space using the depth projection matrix: */
Point dp(vertices[*tiPtr].position.getXyzw());
Point cp=ip.depthProjection.transform(dp);
/* Transform the depth-space point to texture space using the color projection matrix: */
Point tp=ip.colorProjection.transform(dp);
/* Add the point to the bounding box: */
pBox.addPoint(cp);
/* Store the point and its texture coordinates: */
pnts.writePoint(cp);
vmap.writeVarIndex(numUsedVertices);
for(int i=0;i<2;++i)
vmap.write<Misc::Float32>(tp[i]);
++numUsedVertices;
}
}
/* Write the bounding box: */
bbox.writeBox(pBox);
/* Write the BBOX, PNTS, and VMAP chunks: */
bbox.writeChunk();
pnts.writeChunk();
vmap.writeChunk();
}
/* Create the POLS chunk: */
{
IFFChunkWriter pols(&form,"POLS");
pols.write<char>("FACE",4);
const Kinect::MeshBuffer::Index* tiPtr=mesh.getTriangleIndices();
for(unsigned int triangleIndex=0;triangleIndex<mesh.numTriangles;++triangleIndex,tiPtr+=3)
{
pols.write<Misc::UInt16>(3U);
for(int i=0;i<3;++i)
pols.writeVarIndex(indices[tiPtr[2-i]]);
}
pols.writeChunk();
}
/* Delete the vertex index map: */
delete[] indices;
/* Create the PTAG chunk: */
{
IFFChunkWriter ptag(&form,"PTAG");
ptag.write<char>("SURF",4);
for(unsigned int triangleIndex=0;triangleIndex<mesh.numTriangles;++triangleIndex)
{
ptag.writeVarIndex(triangleIndex);
ptag.write<Misc::UInt16>(0U);
}
ptag.writeChunk();
}
/* Create the CLIP chunk: */
{
IFFChunkWriter clip(&form,"CLIP");
clip.write<Misc::UInt32>(1U);
/* Create the STIL chunk: */
{
IFFChunkWriter stil(&clip,"STIL",true);
stil.writeString(textureFileName.c_str());
stil.writeChunk();
}
clip.writeChunk();
}
/* Create the SURF chunk: */
{
IFFChunkWriter surf(&form,"SURF");
surf.writeString("ColorImage");
surf.writeString("");
/* Create the SIDE subchunk: */
{
IFFChunkWriter side(&surf,"SIDE",true);
side.write<Misc::UInt16>(3U);
side.writeChunk();
}
/* Create the SMAN subchunk: */
{
IFFChunkWriter sman(&surf,"SMAN",true);
sman.write<Misc::Float32>(Math::rad(90.0f));
sman.writeChunk();
}
/* Create the COLR subchunk: */
{
IFFChunkWriter colr(&surf,"COLR",true);
colr.writeColor(1.0f,1.0f,1.0f);
colr.writeVarIndex(0U);
colr.writeChunk();
}
/* Create the DIFF subchunk: */
{
IFFChunkWriter diff(&surf,"DIFF",true);
diff.write<Misc::Float32>(1.0f);
diff.writeVarIndex(0U);
diff.writeChunk();
}
/* Create the LUMI subchunk: */
{
IFFChunkWriter lumi(&surf,"LUMI",true);
lumi.write<Misc::Float32>(0.0f);
lumi.writeVarIndex(0U);
lumi.writeChunk();
}
/* Create the BLOK subchunk: */
{
IFFChunkWriter blok(&surf,"BLOK",true);
/* Create the IMAP subchunk: */
{
IFFChunkWriter imap(&blok,"IMAP",true);
imap.writeString("1");
/* Create the CHAN subchunk: */
{
IFFChunkWriter chan(&imap,"CHAN",true);
chan.write<char>("COLR",4);
chan.writeChunk();
}
imap.writeChunk();
}
/* Create the PROJ subchunk: */
{
IFFChunkWriter proj(&blok,"PROJ",true);
proj.write<Misc::UInt16>(5U);
proj.writeChunk();
}
/* Create the IMAG subchunk: */
{
IFFChunkWriter imag(&blok,"IMAG",true);
imag.writeVarIndex(1U);
imag.writeChunk();
}
/* Create the VMAP subchunk: */
{
IFFChunkWriter vmap(&blok,"VMAP",true);
vmap.writeString("ColorImageUV");
vmap.writeChunk();
}
blok.writeChunk();
}
/* Write the SURF chunk: */
surf.writeChunk();
}
/* Write the FORM chunk: */
form.writeChunk();
}
}
void
NetworkObject::generateCylinderSpriteTexture(Vec lightVector)
{
int texsize = 64;
float fp = 0.5f+0.5f*lightVector.y;
QLinearGradient lg(0, 0,
texsize, 0);
lg.setColorAt(0.0, Qt::black);
lg.setColorAt(1.0, Qt::black);
lg.setColorAt(fp, Qt::white);
QImage texImage(texsize, texsize, QImage::Format_ARGB32);
texImage.fill(0);
QPainter p(&texImage);
p.setBrush(QBrush(lg));
p.setPen(Qt::transparent);
//p.drawEllipse(0, 0, texsize, texsize);
p.drawRect(0, 0, texsize, texsize);
uchar *thetexture = new uchar[2*texsize*texsize];
const uchar *bits = texImage.bits();
for(int i=0; i<texsize*texsize; i++)
{
uchar lum = 255;
float a = (float)bits[4*i+2]/255.0f;
a = 1-a;
if (a < 0.5)
{
if (lightVector.z >= 0.0)
a = qMax(a/0.5f, 0.5f);
else
{
a = 0.7f;
lum = 50;
}
}
else if (a >= 1)
{
a = 0;
lum = 0;
}
else
{
if (lightVector.z >= 0.0f)
{
a = 1-(a-0.5f)/0.5f;
lum *= a;
a = 0.9f;
}
else
{
lum *= 1-fabs(a-0.75f)/0.25f;
a = 0.9f;
}
}
a *= 255;
thetexture[2*i] = lum;
thetexture[2*i+1] = a;
}
glActiveTexture(GL_TEXTURE0);
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, Global::cylinderTexture());
glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA,
texsize, texsize, 0,
GL_LUMINANCE_ALPHA, GL_UNSIGNED_BYTE,
thetexture);
delete [] thetexture;
}
