//----------
bool Sender::send(const ofTexture & texture, bool flipY) {
try {
if (!this->isInitialized()) {
throw("Not initialised");
}
//check if the sender matches the settings of the texture
if (this->width != texture.getWidth() || this->height != texture.getHeight()) {
this->width = texture.getWidth();
this->height = texture.getHeight();
//update the sender to match local settings
char mutableName[256];
strcpy_s(mutableName, channelName.size() + 1, channelName.c_str());
if (!this->spoutSender->UpdateSender(mutableName, this->width, this->height)) {
throw("Can't update sender");
}
this->channelName = string(mutableName);
}
//send texture and retain any fbo bound for drawing
GLint drawFboId = 0;
glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &drawFboId);
this->spoutSender->SendTexture(texture.getTextureData().textureID, texture.getTextureData().textureTarget, this->width, this->height, flipY, drawFboId);
return true;
}
catch (const char * e) {
ofLogError("ofxSpout::Sender::send") << e;
return false;
}
}
//----------------------------------------------------------
void of3dPrimitive::mapTexCoordsFromTexture( ofTexture& inTexture ) {
bool bNormalized = true;
#ifndef TARGET_OPENGLES
bNormalized = (inTexture.getTextureData().textureTarget!=GL_TEXTURE_RECTANGLE_ARB);
#endif
ofTextureData& tdata = inTexture.getTextureData();
if(bNormalized)
mapTexCoords( 0, 0, tdata.tex_t, tdata.tex_u );
else
mapTexCoords(0, 0, inTexture.getWidth(), inTexture.getHeight());
ofVec4f tcoords = getTexCoords();
mapTexCoords(tcoords.x, tcoords.y, tcoords.z, tcoords.w);
}
void OpenCLImage::initFromTexture(ofTexture &tex,
cl_mem_flags memFlags,
int mipLevel)
{
ofLog(OF_LOG_VERBOSE, "OpenCLImage::initFromTexture");
init(tex.getWidth(), tex.getHeight(), 1);
cl_int err;
if(clMemObject) clReleaseMemObject(clMemObject);
clMemObject = clCreateFromGLTexture2D(pOpenCL->getContext(), memFlags, tex.getTextureData().textureTarget, mipLevel, tex.getTextureData().textureID, &err);
assert(err != CL_INVALID_CONTEXT);
assert(err != CL_INVALID_VALUE);
// assert(err != CL_INVALID_MIPLEVEL);
assert(err != CL_INVALID_GL_OBJECT);
assert(err != CL_INVALID_IMAGE_FORMAT_DESCRIPTOR);
assert(err != CL_OUT_OF_HOST_MEMORY);
assert(err == CL_SUCCESS);
assert(clMemObject);
texture = &tex;
hasCorrespondingGLObject = true;
}
//---------------------------------------------------------------------
void ofDrawBitmapCharacterStart(int stringLength) {
verts.clear();
coords.clear();
verts.assign(12 * (stringLength+1), 0);
coords.assign(12 * (stringLength+1), 0);
if(!bBitmapTexturePrepared) {
prepareBitmapTexture();
}
glesBitmappedFontTexture.bind();
#ifndef TARGET_OPENGLES
// this temporarily enables alpha testing,
// which discards pixels unless their alpha is 1.0f
glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT);
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_EQUAL, 1.0f);
#endif
glEnableClientState(GL_VERTEX_ARRAY);
glEnableClientState( GL_TEXTURE_COORD_ARRAY );
glTexParameterf(glesBitmappedFontTexture.getTextureData().textureTarget, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
vC = 0;
}
void copy(S& src, ofTexture& tex) {
imitate(tex, src);
int w = tex.getWidth(), h = tex.getHeight();
int glType = tex.getTextureData().glTypeInternal;
Mat mat = toCv(src);
tex.loadData(mat.ptr(), w, h, glType);
}
void ofxShader::setUniformTexture(const char* name, ofTexture& tex, int textureLocation) {
if(bLoaded) {
ofTextureData texData = tex.getTextureData();
glActiveTexture(GL_TEXTURE0 + textureLocation);
glEnable(texData.textureTarget);
glBindTexture(texData.textureTarget, texData.textureID);
glDisable(texData.textureTarget);
setUniform1i(name, textureLocation);
glActiveTexture(GL_TEXTURE0);
}
}
void GLTexture::initFromOFTexture(ofTexture &texture)
{
tex[0] = texture.getTextureData().textureID;
type = texture.texData.glType;
texTarget = texture.texData.textureTarget; //texTarget GL_TEXTURE_1D, GL_TEXTURE_2D, GL_TEXTURE_RECTANGLE_ARB,
texInternalFormat = texture.texData.glTypeInternal; //GL_RGBA, GL_RGBA16F_ARB, GL_RGBA32F_ARB;
minFilter = GL_LINEAR; //GL_NEAREST, GL_LINEAR
magFilter = GL_LINEAR; //GL_NEAREST, GL_LINEAR
width = texture.getWidth();
height = texture.getHeight();
}
GLuint ofxImGui::loadTexture(ofTexture& texture, string imagePath)
{
bool isUsingArb = ofGetUsingArbTex();
if (isUsingArb)
{
ofDisableArbTex();
}
ofLoadImage(texture, imagePath);
if (isUsingArb)
{
ofEnableArbTex();
}
return texture.getTextureData().textureID;
}
//--------------------------------------------------------------
void ofShader::setUniformTexture(const string & name, const ofTexture& tex, int textureLocation) const{
if(bLoaded) {
ofTextureData texData = tex.getTextureData();
glActiveTexture(GL_TEXTURE0 + textureLocation);
if (!ofIsGLProgrammableRenderer()){
glEnable(texData.textureTarget);
glBindTexture(texData.textureTarget, texData.textureID);
glDisable(texData.textureTarget);
} else {
glBindTexture(texData.textureTarget, texData.textureID);
}
setUniform1i(name, textureLocation);
glActiveTexture(GL_TEXTURE0);
}
}
// get pixels from a fbo or texture // untested
void ftUtil::toPixels(ofTexture& _tex, ofPixels& _pixels) {
ofTextureData& texData = _tex.getTextureData();
int format = texData.glInternalFormat;
int readFormat, numChannels;
switch(format){
case GL_R8: readFormat = GL_RED, numChannels = 1; break; // or is it GL_R
case GL_RG8: readFormat = GL_RG, numChannels = 2; break;
case GL_RGB8: readFormat = GL_RGB, numChannels = 3; break;
case GL_RGBA8: readFormat = GL_RGBA, numChannels = 4; break;
default:
ofLogWarning("ftUtil") << "toPixels: " << "can only read char texturs to ofPixels";
return;
}
if (_pixels.getWidth() != texData.width || _pixels.getHeight() != texData.height || _pixels.getNumChannels() != numChannels) {
_pixels.allocate(texData.width, texData.height, numChannels);
}
ofSetPixelStoreiAlignment(GL_PACK_ALIGNMENT, texData.width, 1, numChannels);
glBindTexture(texData.textureTarget, texData.textureID);
glGetTexImage(texData.textureTarget, 0, readFormat, GL_UNSIGNED_BYTE, _pixels.getData());
glBindTexture(texData.textureTarget, 0);
}
//----------
bool Receiver::receive(ofTexture & texture) {
try {
//check if we're initialised
if (!this->isInitialized()) {
throw("Not initialized");
}
//prepare the channel name, allow it to be changed if different channels are available
char mutableName[256];
unsigned int mutableWidth, mutableHeight;
strcpy_s(mutableName, this->channelName.size() + 1, this->channelName.c_str());
//check if the texture is allocated correctly, if not, allocate it
if (texture.getWidth() != this->width || texture.getHeight() != this->height) {
int format = texture.isAllocated() ? texture.getTextureData().glInternalFormat : this->defaultFormat;
texture.allocate(width, height, format);
}
//pull data into the texture (keep any existing fbo attachments)
GLint drawFboId = 0;
glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, &drawFboId);
if (!this->spoutReceiver->ReceiveTexture(mutableName, mutableWidth, mutableHeight, texture.getTextureData().textureID, texture.getTextureData().textureTarget, false, drawFboId)) {
throw("Can't receive texture");
}
//update our local settings incase anything changed
this->channelName = mutableName;
this->width = mutableWidth;
this->height = mutableHeight;
return true;
}
catch (const char * e) {
ofLogError("ofxSpout::Receiver::receive") << e;
return false;
}
}
void CubeMap::flipSurface(ofTexture & surf)
{
unsigned char* data = surf.getTextureData();
int w = surf.getRowBytes();
int h = surf.getHeight();
char r,g,b,a=0;
// for(int i = 0 ; i < w*h*100; i++)
// data[i] = 10;
int pixInc = surf.getPixelInc();
for(int j = 0; j < h; j++)
{
for(int i = 0; i < 256; i++)
{
int index =pixInc*i+j*w;
int nIndex = (j+1)*w-(i)*pixInc;
r = data[index];
g = data[index+1];
b = data[index+2];
a = data[index+3];
data[index] = data[nIndex];
data[index+1] = data[nIndex+1];
data[index+2] = data[nIndex+2];
data[index+3] = data[nIndex+3];
data[nIndex] = r;
data[nIndex+1] = g;
data[nIndex+2] = b;
data[nIndex+3] = a;
}
}
}
void ofxPBO::allocate(ofTexture & tex, int numPBOs){
pboIds.resize(numPBOs);
glGenBuffersARB(numPBOs, &pboIds[0]);
int numChannels=1;
switch(tex.getTextureData().glTypeInternal){
case GL_LUMINANCE:
numChannels = 1;
break;
case GL_RGB:
numChannels = 3;
break;
case GL_RGBA:
numChannels = 4;
break;
}
dataSize = tex.getWidth()*tex.getHeight()*numChannels;
for(int i=0;i<(int)pboIds.size();i++){
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, pboIds[i]);
glBufferDataARB(GL_PIXEL_UNPACK_BUFFER_ARB, dataSize, 0, GL_STREAM_DRAW_ARB);
}
glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
texture = tex;
}
void ofMaterial::setCustomUniformTexture(const std::string & name, const ofTexture & value, int textureLocation){
uniformstex[name] = {value.getTextureData().textureTarget, int(value.getTextureData().textureID), textureLocation};
}
CubeMap::CubeMap( GLsizei texWidth,
GLsizei texHeight,
const ofTexture &pos_x,
const ofTexture &pos_y,
const ofTexture &pos_z,
const ofTexture &neg_x,
const ofTexture &neg_y,
const ofTexture &neg_z )
{
mWidth = texWidth;
mHeight = texHeight;
setupCapture();
// glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
//create a texture object
glGenTextures(1, &textureObject);
glBindTexture(GL_TEXTURE_CUBE_MAP_ARB, textureObject);
//assign the images to positions
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_X_ARB, 0, GL_RGBA, texWidth, texHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, pos_x.getTextureData());
glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_X_ARB, 0, GL_RGBA, texWidth, texHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, neg_x.getTextureData());
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Y_ARB, 0, GL_RGBA, texWidth, texHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, pos_y.getTextureData());
glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_ARB, 0, GL_RGBA, texWidth, texHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, neg_y.getTextureData());
glTexImage2D(GL_TEXTURE_CUBE_MAP_POSITIVE_Z_ARB, 0, GL_RGBA, texWidth, texHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, pos_z.getTextureData());
glTexImage2D(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_ARB, 0, GL_RGBA, texWidth, texHeight, 0, GL_RGB, GL_UNSIGNED_BYTE, neg_z.getTextureData());
//set filtering modes for scaling up and down
glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_CUBE_MAP_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
}
