常連

###前提・実現したいこと
ダブルタップで別クラスで定義したメソッドを呼んで
画面上に表示した点の認識を行うことができるようにしようとしました。

しかしダブルタップをした瞬間に問題が発生し
「発生している問題・エラーメッセージ」の欄に書いてある

java.lang.IllegalArgumentException: length - offset < n

というエラーが発生していました。

このエラー自体はオラクルのホームページを見ると
「不正な引数、または不適切な引数をメソッドに渡したことを示すためにスローされます。」
という事みたいですが引数の何が不適切なのか
また「length - offset < n」がなにかわからない状態です。

「該当のソースコード」にはエラーメッセージで指摘されている場所が含まれるメソッドを記載しています。

そこでこのエラーを解決するのに必要な手順を教えていただけると幸いです。

よろしくお願いいたします。
###発生している問題・エラーメッセージ


```
java.lang.IllegalArgumentException: length - offset < n
                      at android.opengl.Matrix.multiplyMV(Native Method)
                      at android.opengl.GLU.gluUnProject(GLU.java:237)
```

###該当のソースコード
値を渡す側のメソッド
```java
@Override
    public boolean onDoubleTap(MotionEvent motionEvent) {
       
        int x = (int) motionEvent.getX();
        int y = (int) motionEvent.getY();
        float x1 = motionEvent.getX();
        float y1 = motionEvent.getY();

        float y2 = 1280-y1;

        Log.d("y2", "y2 ;"+ y2);

        PPS.PickUpPoint2(gl11,x1,y2);

        Log.d("onDoubleTap", "x:" + x + ",y:" + y);
        return false;
    }
```

値を渡した側のメソッド
```java
	public boolean PickUpPoint2(GL11 gl11,float x1, float y2) {

		int i, j, k;
		int flagi = 0;
		int flagj = 0;
		int flagk = 0;
		float dis, mindis;

		PickUpPoint_flag = false;

		mindis = 5.0f;

		for (i = 0; i < ncpt[0]; i++) {
			if (i == 0 || i == ncpt[0] - 1) {
				flagi = 1;
			} else {
				flagi = 0;
			}
			for (j = 0; j < ncpt[1]; j++) {
				if (j == 0 || j == ncpt[1] - 1) {
					flagj = 1;
				} else {
					flagj = 0;
				}
				for (k = 0; k < ncpt[2]; k++) {
					if (k == 0 || k == ncpt[2] - 1) {
						flagk = 1;
					} else {
						flagk = 0;
					}

					if (flagi + flagj + flagk > 0) {

						float CPX = CP[i][j][k][0];
						float CPY = CP[i][j][k][1];
						float CPZ = CP[i][j][k][2];

						gl11.glGetFloatv(GL11.GL_MODELVIEW_MATRIX, model_f, modelOffset);
						gl11.glGetFloatv(GL11.GL_PROJECTION_MATRIX, project_f, projectOffset);
						gl11.glGetIntegerv(GL11.GL_VIEWPORT, view, viewOffset);

						GLU.gluUnProject(
								x1, y2, 0,
								model_f, modelOffset,
								project_f, projectOffset,
								view, viewOffset,
								nearobj, nearobjOffset
						);

						dis = (float) sqrt((nearobj[0] - CPX) * (nearobj[0] - CPX) + 
            (nearobj[1] - CPY) * (nearobj[1] - CPY) + (nearobj[2] - CPZ) * (nearobj[2] - CPZ));

						if (dis <= mindis) {
							mindis = dis;
							i_sel=i;
							j_sel=j;
							k_sel=k;
							PickUpPoint_flag = true;
					}
				}
			}
		}
	}

		return PickUpPoint_flag;
	}

```

IllegalArgumentExceptionの解決法を教えてください。

###前提・実現したいこと
GLSL1.2で記述されている、バーテックスとフラグメントシェーダーをGLSL1.5に書き換えたいのですが全くわからないので教えていただきたいです。

###ソースコード
fragment
```GLSL
#version 120
uniform sampler2DRect image;
uniform float rand;

varying vec3 pos;

void main (void)
{
    vec2 texCoord = vec2(pos.x , pos.y);

    vec4 col = texture2DRect(image,texCoord);
    vec4 col_r = texture2DRect(image,texCoord + vec2(-35.0*rand,0));
    vec4 col_l = texture2DRect(image,texCoord + vec2( 35.0*rand,0));
    vec4 col_g = texture2DRect(image,texCoord + vec2( -7.5*rand,0));
    

    col.b = col.b + col_r.b*max(1.0,sin(pos.y*1.2)*2.5)*rand;
    col.r = col.r + col_l.r*max(1.0,sin(pos.y*1.2)*2.5)*rand;
    col.g = col.g + col_g.g*max(1.0,sin(pos.y*1.2)*2.5)*rand;

    gl_FragColor.rgba = col.rgba;
}

```

vertex
```GLSL
#version 120
varying vec3 pos;
void main(void)
{
    pos = gl_Vertex.xyz;
    gl_Position = ftransform();
}
```

この２つを#version150の形に直したいです

GLSL1.2をGLSL1.5に書き換える

###前提・実現したいこと
Unityで外部プラグインを作成してOpenGL ESで長方形(FillRect)を描画しようとしたところ、
「GL_INVALID_OPERATION: Operation illegal in current state」が発生し、
何も描画されない状態になってしまいます。

どこか根本的に間違っている部分や設定漏れがあるのではと考えておりますが、
数日間、原因を調査しても解決しなかったので、皆様のお力をお借りできればと思います。
お手数ですが、何卒宜しくお願い致します。 

###ソースコード
```c++
// 頂点シェーダー
#define VERTEX_C_SRC(ver, attr, varying)							\
	ver																\
	attr " highp vec4 a_vertex;\n"									\
	attr " lowp vec4 a_color;\n"							\
	"\n"															\
	"uniform highp mat4 u_ModelViewProj;\n"							\
	"\n"															\
	varying " lowp vec4 v_color;\n"									\
	"\n"															\
	"void main()\n"													\
	"{\n"															\
	"	gl_Position = u_ModelViewProj * a_vertex;\n"				\
	"	v_color = a_color;\n"										\
	"}\n"															\

static const char* c_VProgTextGLES2		= VERTEX_C_SRC("\n", "attribute", "varying");
static const char* c_VProgTextGLES3		= VERTEX_C_SRC("#version 300 es\n", "in", "out");
static const char* c_VProgTextGLCore	= VERTEX_C_SRC("#version 150\n", "in", "out");



// フラグメントシェーダー
#define FRAGMENT_C_SRC(ver, varying, outDecl, outVar)				\
	ver																\
	outDecl															\
	varying " lowp vec4 v_color;\n"									\
	"\n"															\
	"void main()\n"													\
	"{\n"															\
	"	" outVar " = v_color;\n"									\
	"}\n"															\

static const char* c_FShaderTextGLES2	= FRAGMENT_C_SRC("\n", "varying", "\n", "gl_FragColor");
static const char* c_FShaderTextGLES3	= FRAGMENT_C_SRC("#version 300 es\n", "in", "out lowp vec4 fragColor;\n", "fragColor");
static const char* c_FShaderTextGLCore	= FRAGMENT_C_SRC("#version 150\n", "in", "out lowp vec4 fragColor;\n", "fragColor");
```

```C++
class Shader
{
public:
	GLuint		m_Program;
	GLuint		m_VertShader;
	GLuint		m_FragShader;
	GLint*		m_piGLAttrib;
	GLint		m_iGLAttribNum;
	GLint*		m_piGLUniform;
	GLint		m_iGLUniformNum;
	UnityGfxRenderer m_APIType;

	Shader( const char* vert, const char* frag, const int* attribIndex, const char** attribName, int attribNum, const int* uniformIndex, const char** uniformName, int uniformNum, UnityGfxRenderer APIType)
	{
		m_Program = 0;
		m_VertShader = 0;
		m_FragShader = 0;
		m_iGLAttribNum = 0;
		m_piGLAttrib = NULL;
		m_iGLAttribNum = 0;
		m_piGLUniform = NULL;
		m_APIType = APIType;

		createShader( vert, frag, attribIndex, attribName, attribNum, uniformIndex, uniformName, uniformNum);
	}

	boolean createShader( const char* vert, const char* frag, const int* attribIndex, const char** attribName, int attribNum, const int* uniformIndex, const char** uniformName, int uniformNum)
	{
		// プログラムオブジェクトの作成
		m_Program = glCreateProgram();
		if( m_Program == 0 ){
			goto _ERROR;
		}
	
		if( FALSE == compileShader( &m_VertShader, GL_VERTEX_SHADER, vert) ){
			goto _ERROR;
		}
		if( FALSE == compileShader( &m_FragShader, GL_FRAGMENT_SHADER, frag) ){
			goto _ERROR;
		}
		
		// シェーダオブジェクトのシェーダプログラムへの登録
		glAttachShader( m_Program, m_VertShader );
		glAttachShader( m_Program, m_FragShader );
	
	#if SUPPORT_OPENGL_CORE
		if (m_APIType == kUnityGfxRendererOpenGLCore)
			glBindFragDataLocation(m_Program, 0, "fragColor");
	#endif // if SUPPORT_OPENGL_CORE

		// シェーダプログラムのリンク
		glLinkProgram( m_Program );
	
		// プログラムの検証
		glValidateProgram( m_Program );
	
		// リンクフェーズで決定されたuniform locationをすべて取得
		if( FALSE == getAttribLocations( attribIndex, attribName, attribNum ) ){
			goto _ERROR;
		}	
		// リンクフェーズで決定されたattrib locationをすべて取得
		if( FALSE == getUniformLocations( uniformIndex, uniformName, uniformNum ) ){
			goto _ERROR;
		}
		
		// シェーダオブジェクトの削除
		releaseShader();
		
		return TRUE;
		
	_ERROR:
		release();
		return FALSE;
	}


	boolean compileShader(GLuint* shader, GLenum type, const char* source)
	{
		GLint iGLStatus;
	
		if( source == NULL ){
			return FALSE;
		}
	
		*shader = glCreateShader( type );
		if( *shader == 0 ){
			goto _ERROR;
		}

		// シェーダのソースプログラムのシェーダオブジェクトへの読み込み
		glShaderSource(*shader, 1, (const GLchar**)&source, NULL);

		// シェーダのソースプログラムのコンパイル
		glCompileShader( *shader );
	
		glGetShaderiv( *shader, GL_COMPILE_STATUS, &iGLStatus );
		if( iGLStatus == 0 ){
			goto _ERROR;
		}
		
		return TRUE;

	_ERROR:
		if( *shader ){
			glDeleteShader( *shader );
			*shader = 0;
		}
		return FALSE;	
	}

	void releaseShader()
	{
		if( m_VertShader )
		{
			glDeleteShader( m_VertShader );
			m_VertShader = 0;
		}
		if( m_FragShader )
		{
			glDeleteShader( m_FragShader );
			m_FragShader = 0;
		}
	}

	void useShader()
	{
		glUseProgram( m_Program );
	}

	boolean getAttribLocations( const int* index, const GLchar** name, int32 num )
	{
		glGetProgramiv( m_Program, GL_ACTIVE_ATTRIBUTES, &m_iGLAttribNum );
		
		m_piGLAttrib = new GLint[ num ];
		for( int i = 0 ; i < num ; i++ )
		{
			if( m_piGLAttrib == NULL )	continue;
			m_piGLAttrib[ index[ i ] ] = glGetAttribLocation( m_Program, name[ i ] );
		}
		
		return TRUE;
	}

	boolean getUniformLocations( const int* index, const GLchar** name, int32 num )
	{
		glGetProgramiv( m_Program, GL_ACTIVE_UNIFORMS, &m_iGLUniformNum );
	
		m_piGLUniform = new GLint[ num ];
		for( int i = 0 ; i < num ; i++ )
		{
			if( m_piGLUniform == NULL )	continue;
			m_piGLUniform[ index[ i ] ] = glGetUniformLocation( m_Program, name[ i ] );
		}
	
		return TRUE;
	}
}
```

OpenGL ESで長方形を描画すると「GL_INVALID_OPERATION: Operation illegal in current state」が発生します

###前提・実現したいこと
OpenGL ES 1.0で表示させた3次元空間上の点の色を読み取ろうと考えて
タッチした場所のピクセル値を読み取りその色が点の色だったら
「点が選択されています」という表示を出そうと思いました。

しかしなかなかうまくいかないため原因を探ろうと思って
Android Studioのログ上でタッチした場所のピクセル値を吐き出すようにしました。

すると点の部分はおろかどの部分をタッチしてもピクセル値はすべて-1となってしまいました。

背景は下のプログラムにありますように真っ白なので背景をタッチしたときに
ピクセル値としてはすべてに255が入らないとまずいと思います。

予測している原因としてはglReadPixelsがそもそもうまくいっていないか
読み取ったピクセル値がうまく配列に入っていないからなのかと思うのですが
いまいち何が悪いのかはっきりしないのでお力をお貸しいただけると幸いです。

###発生している問題・エラーメッセージ
吐き出されているログ
```
//タッチした場所の座標をint型で定義
D/TouchEvent: x:361,y:792
//タッチした場所のピクセル値（RGBA順）
D/Pixel: 0:-1,1:-1,2:-1,3:-1
```

###該当のソースコード
画面をタッチした時のプログラム
```java
final int x = (int) event.getX();
final int y = (int) event.getY();
final byte pixel[] = new byte[4];
final ByteBuffer bb_pixel = ByteBuffer.allocateDirect(pixel.length);
bb_pixel.order(ByteOrder.nativeOrder());
bb_pixel.put(pixel);
bb_pixel.position(0);
switch (Action & MotionEvent.ACTION_MASK) {
   case MotionEvent.ACTION_DOWN:
       queueEvent(new Runnable() {
           @Override
           public void run() {
              GLES10.glReadPixels(x,y,1,1,GLES10.GL_RGBA,GLES10.GL_UNSIGNED_BYTE,bb_pixel);
              Log.d("TouchEvent","x:"+x+",y:"+y);
              Log.d("Pixel","0:"+bb_pixel.get(0)+",1:"+bb_pixel.get(1)+",2:"+bb_pixel.get(2)+",3:"+bb_pixel.get(3));
              if (bb_pixel.get(0)==(byte)0)
              {
                 Toast.makeText(getContext(),"選択されました",Toast.LENGTH_SHORT).show();
              }
           }
        });

```
背景の定義
```java
@Override
	public void onDrawFrame(GL10 gl) {
		
		gl.glClearColor(1.0f, 1.0f, 1.0f, 1.0f);//背景カラー(白)
		
      以下省略

	}
```


###補足情報(言語/FW/ツール等のバージョンなど)
OpenGL ES 1.0

glReadPixelsでピクセル値が読み取れていない？or読み取った値がうまく配列に入っていない？

私は今、cocos2d-x ver3.2 を使用してゲーム開発を行っています。
その際ver3.2から追加された機能であるSprite3Dでc3t・c3bファイル(3Dモデルデータ)の読み込み・表示・モーション再生を実装したいと思っています。
しかし、作成した3Dモデルデータをc3t・c3bファイルに変換した時に読み込みエラーが発生してしまいます。
サンプルで付属していたc3bファイルの読み込み・表示・モーション再生は成功しているので、ゲームのプログラム側ではなく3Dモデリングソフトから.fbx形式で書き出す時の設定ミスではないか？と考えているのですが手詰まり状態となっています。

**使用環境**
> cocos2d-x ver3.2
> android-ndk-r9d
> android-sdk-r24
> apache-ant-1.9.4

**Windows**
> 3dsmax 2015
> VisualStudio 2013 Professional

**mac**
> Xcode 6.1

**code**
```lang-C++
HelloWorldScene.cpp
bool HelloWorld::init()
{
	// cocos2d-x側の初期化
	if ( !Layer::init() )
	{
		return false;
	}
	// 背景を白に設定
	auto _bg = LayerColor::create(Color4B::WHITE, visibleSize.width, visi	bleSize.height);
	// レイヤーに登録
	this -> addChild(_bg);
	// モデルデータの読み込み
	auto sprite3d = Sprite3D::create( "test.c3t");
	// テクスチャをセット
	sprite3d -> setTexture( "test.png");
	// レイヤーに登録
	addChild( sprite3d);
	// アニメーション情報をスプライトに登録
	auto animation = Animation3D::create( "sarari.c3b");
	auto animate = Animate3D::create( animation, 1.933f, 2.8f);
	sprite3d -> runAction( RepeatForever::create( animate));
	// 画面のほぼ中心に表示
	sprite3d -> setPosition( Vec2( visibleSize.width / 2, visibleSize.height / 3));
	// 奥行きはとりあえず初期値
	sprite3d -> setPositionZ( 0.0);
	// サイズを適当に拡大
	sprite3d -> setScale( 14.0f);
	// 表示されているモデルを回転させる
	auto rotation = RotateBy::create( 10, Vec3(0, 360, 0));
	sprite3d -> runAction( RepeatForever::create( rotation));
}
```

以下3dsmax側の設定

![イメージ説明][WIDTH:600](4301be7a538a859e914aec706fad1173.png)
![イメージ説明][WIDTH:600](c5e7d1d721c73a9732343402e8c96092.png)

どなたかご助力をよろしくお願いします。

【cocos2d-x】3Dモデルの作成→FBX形式への変換について【3dsmax】

頂点(x1,y1)(x2,y2)(x3,y3)の三角形を
glRotatef(45.0f, 0.0f, 0.0f, 1.0f)で45度のz軸回転をさせた後の座標
(x1',y1')(x2',y2')(x3',y3')の値が知りたいです

下記のコードで、点(0.0f, 0.3f) 点(-0.2f, -0.2f) 点(0.2f, -0.2f)の三角形を45度回転させて画面に表示することができるのですが
各頂点の回転後の値を引っ張ってきて、使用することは可能でしょうか？

```kotlin
　　　　　gl10.glPushMatrix() //glPushMatrixとglPopMatrixで挟んだ行のみglRotatef回転の対象となる
 
        gl10.glColor4f(1.0f, 0.0f, 0.0f, 1.0f)  //赤色
        gl10.glRotatef(45.0f, 0.0f, 0.0f, 1.0f)  //45度z軸回転
        drawTriangle(gl10, 0.0f, 0.3f, -0.2f, -0.2f, 0.2f, -0.2f) //入力した座標の三角形を表示する

        gl10.glPopMatrix()
```

上記の glRotatef() であればGPU上で計算できるので利用できれば処理が高速になるのでは？と考えています
現在はsin, cos使って計算した後の値をdrawTriangle()に入れて計算後の値をOpenGLで表示しています

OpenGL 回転座標で変換後の座標(x',y')の値を使用したい

###前提・実現したいこと
OpenGLを使用して背景を透過して画像を画面に表示することを目指しています。
テクスチャを使用して、画面に板状のポリゴンを描画し、画像を表示するところまでは出来ています。
実装上の事情があり、アルファを含んだPNG画像等を使用することが出来ません。
その代わりにアルファ値を表現するグレースケールの画像を使用出来るのですが、この画像を利用して
RGBの値をアルファ値として持つテクスチャを作成できないでしょうか。

最終的には、画像テクスチャとアルファテクスチャの二つを以下のようにブレンディングすることで、
背景を透過した表示(例えばキャラクタの切り抜き等)を実現したいと考えています。

glBlendFuncSeparate(GL_ONE, GL_ZERO, GL_ZERO, GL_ONE);
sを画像テクスチャ、dをアルファテクスチャとする。
(sR * 1, sG * 1, sB * 1, sA * 0) + (sR * 0, sG * 0, sB * 0, sA * 1) = (sR, sG, sB, dA)

###知りたいこと
グレースケール画像から、各画素のR値(またはB、Gでも良い)が各画素のアルファ値になるようなテクスチャを
作成する方法についてご存じの方がいらっしゃいましたらご教授下さい。
宜しくお願い致します。

###補足情報(言語/FW/ツール等のバージョンなど)
他のライブラリの兼ね合いによりOpenGLES1.1Extまでの内容で実装したいと考えています。
よって、シェーダプログラムは利用できません。
また、更新が頻繁に起こるので、配列でのアクセスは極力避けたいと考えています。

[OpenGL]グレースケールイメージをアルファマスクとして使用できますか？

### 概要
XamarinでiOS用のOpenGL描画システムを構築中です。
ポリゴン並びにテクスチャの描画で、作業が詰まってしまいました。

以下にプログラムソースの抜粋を記します。

### 変数定義

``` C#
		private EAGLContext mContext = null;

		private uint mFrameBuffer;
		private uint mRenderBuffer;

		private int mWidth = -1;
		private int mHeight = -1;
		private float mScreenScale = 1.0f;

		private int[] mTextureID;
		private NSData[] mTextureBitmap;
		private int[,] mTextureSize;

```

### 描画処理本体

``` C#
		public override void LayoutSubviews()
		{
			try
			{
				// 画面サイズの取得
				CGRect size = UIScreen.MainScreen.Bounds;
				mWidth = (int)size.Width;
				mHeight = (int)size.Height;

				// カレントコンテキストの設定
				EAGLContext.SetCurrentContext(mContext);
				GL.Oes.BindFramebuffer(All.FramebufferOes, mFrameBuffer);

				// 描画の初期化
				GL.Enable((All)EnableCap.Texture2D);
				GL.Enable((All)EnableCap.AlphaTest);
				GL.Enable((All)EnableCap.Blend);
				GL.BlendFunc((All)BlendingFactorSrc.SrcAlphaSaturate, (All)BlendingFactorDest.OneMinusSrcAlpha);

				// 黄色でクリア
				GL.ClearColor(1.0f, 1.0f, 0.0f, 1.0f);

				// バッファクリア
				GL.Clear(ClearBufferMask.ColorBufferBit | ClearBufferMask.DepthBufferBit);

				// テクスチャをアクティブ
				GL.ActiveTexture(All.Texture0);

				// ポリゴンの描画
				DrawPolygon(0, 0, 100, 100, 1.0f, 0.0f, 0.0f, 1.0f);

				// テクスチャの描画
				BindTexture(0);
				DrawTexture(0, 0, 0, mTextureSize[0, _X], mTextureSize[0, _Y], false);

				GL.Oes.BindRenderbuffer(All.RenderbufferOes, mRenderBuffer);
				mContext.PresentRenderBuffer((uint)All.RenderbufferOes);
			}
			catch (Exception e)
			{
			}
		}

```
### テクスチャ読み込み

``` C#

		public void InitTexture(UIImage[] image, int start, int end)
		{
			int i;
			int len = image.Length;

			// 配列の初期化
			mTextureID = new int[len];
			mTextureSize = new int[len, _XYWH];

			// テクスチャのワークを生成
			GL.GenTextures(len, mTextureID);

			// ゲーム用テクスチャイメージを取得
			for (i = start; i < end; i++)
			{
				if (i >= len) continue;

				CGDataProvider dp = image[i].CGImage.DataProvider;
				NSData data = dp.CopyData();
				mTextureBitmap[i] = data;

				mTextureSize[i, _X] = 0;
				mTextureSize[i, _Y] = (int)image[i].CGImage.Height;
				mTextureSize[i, _W] = (int)image[i].CGImage.Width;
				mTextureSize[i, _H] = (int)-image[i].CGImage.Height;

				GL.BindTexture(All.Texture2D, mTextureID[i]);
				GL.TexParameter(All.Texture2D, All.TextureMinFilter, (int)All.Nearest);
				GL.TexParameter(All.Texture2D, All.TextureMagFilter, (int)All.Nearest);
				GL.TexImage2D(All.Texture2D, 0, (int)PixelInternalFormat.Palette8Rgba8Oes, mTextureSize[i, _X], mTextureSize[i, _Y], 0,
							 (All)OpenTK.Graphics.ES11.PixelFormat.Rgba, (All)PixelType.UnsignedShort4444, data.Bytes);
			}
		}

``` 

### ポリゴン描画

``` C#
		public void DrawPolygon(int _x, int _y, int _w, int _h, float rr, float gg, float bb, float aa)
		{
			int rx = (int)(((float)(_x - (mWidth / 2)) * mScreenScale) + (mWidth / 2));
			int ry = (int)(((float)(_y - (mHeight / 2)) * mScreenScale) + (mHeight / 2));
			int rw = (int)((float)_w * mScreenScale);
			int rh = (int)((float)_h * mScreenScale);

			GL.Disable((All)EnableCap.Texture2D);
			GL.BindTexture(All.Texture2D, 0);

			// ポリゴン描画
			GL.Color4(rr, gg, bb, aa);
			GL.VertexPointer(3, All.Float, 0, MakeVertexBuffer(rx, ry, rw, rh));
			GL.TexCoordPointer(2, All.Float, 0, MakeFullSizeUVBuffer());
			GL.DrawArrays(All.TriangleStrip, 0, 4);

			// テクスチャを有効に戻す
			GL.Enable((All)EnableCap.Texture2D);
		}

```

### テクスチャ描画

``` C#
		public void DrawTexture(int id, float _x, float _y, float _w, float _h, bool isReverse, bool isAbsPos)
		{
			int rx, ry;

			// 絶対座標かの判断
			if (isAbsPos)
			{
				rx = (int)(_x);
				ry = (int)(_y);
			}
			else
			{
				rx = (int)(((_x - (mWidth / 2)) * mScreenScale) + (mWidth / 2));
				ry = (int)(((_y - (mHeight / 2)) * mScreenScale) + (mHeight / 2));
			}

			int rw = (int)((_w * mScreenScale));
			int rh = (int)((_h * mScreenScale));

			int[] tempRect = new int[_XYWH];
			tempRect[_X] = mTextureSize[id, _X];
			tempRect[_Y] = mTextureSize[id, _Y];
			tempRect[_W] = mTextureSize[id, _W];
			tempRect[_H] = mTextureSize[id, _H];

			// 左右反転処理
			if (isReverse)
			{
				tempRect[_X] = tempRect[_W];
				tempRect[_W] *= -1;
			}

			// 切り出しサイズを設定
			GL.TexParameterx(All.Texture2D, All.TextureCropRectOes, tempRect);

			// 実描画
			GL.Oes.DrawTex(rx, (mHeight - (ry + rh)), 0, rw, rh);
		}

```
### 頂点バッファ、ＵＶバッファの生成

``` C#

		public float[] MakeVertexBuffer(int _x, int _y, int _w, int _h)
		{
			//ウィンドウ座標を正規化デバイス座標に変換
			float left   = ((float)_x / (float)mWidth ) * 2.0f - 1.0f;
			float top    = ((float)_y / (float)mHeight) * 2.0f - 1.0f;
			float right  = ((float)(_x + _w) / (float)mWidth ) * 2.0f - 1.0f;
			float bottom = ((float)(_y + _h) / (float)mHeight) * 2.0f - 1.0f;

			// 頂点バッファの生成
			float[] vertexs =
			{
				left,  top,    0.0f,	//頂点0
				left,  bottom, 0.0f,	//頂点1
				right, top,    0.0f,	//頂点2
				right, bottom, 0.0f,	//頂点3
			};
			return MakeFloatBuffer(vertexs);
		}

		public float[] MakeFullSizeUVBuffer()
		{
			float[] fullSize =
			{
				0.0f, 0.0f,
				0.0f, 1.0f,
				1.0f, 0.0f,
				1.0f, 1.0f,
			};
			return MakeUVBuffer(fullSize);
		}

		public float[] MakeUVBuffer(float[] uv)
		{
			return MakeFloatBuffer(uv);
		}

		public float[] MakeFloatBuffer(float[] array)
		{
			return (array);
		}

```

### 詳細
使用しているのは、OpenTK ES1.1です。
これらの元になるソースはAndroidでのOpenGLで基本的に動作した物で、それを移植した物になります。

なお、描画処理本体の『黄色でクリア』の部分までは正常に動作しており、背景は黄色で塗りつぶされています。
必要でしたら、バッファの生成の箇所もアップいたします。

iOSでの詳細な作法が解っていないため、足りない設定などがありましたら、ご指摘をよろしくお願いします。

### 補足
本プロジェクトは、ES1.1で制作することが前提となっています。

### 追記 テクスチャのバインド処理
``` C#
		public void BindTexture(int id)
		{
			GL.BindTexture(All.Texture2D, mTextureID[id]);
		}
```
### 追記 バッファ及びテクスチャの初期化
``` C#
		public void CreateBuffer()
		{
			BackgroundColor = UIColor.Blue;

			CGRect size = UIScreen.MainScreen.Bounds;
			mWidth = (int)size.Width;
			mHeight = (int)size.Height;

			CAEAGLLayer layer = (CAEAGLLayer)Layer;
			layer.Opaque = true;

			// コンテキストの取得
			mContext = new EAGLContext(EAGLRenderingAPI.OpenGLES1);
			EAGLContext.SetCurrentContext(mContext);

			GL.MatrixMode(All.Projection);
			GL.LoadIdentity();

			// ビューポートの設定
			GL.Viewport(0, 0, mWidth, mHeight);
			GL.Scale(1.0f, -1.0f, 1.0f); // Ｙ軸を反転させる

			GL.Enable((All)EnableCap.Texture2D);
			GL.Enable((All)EnableCap.AlphaTest);
			GL.Enable((All)EnableCap.Blend);

			GL.EnableClientState(All.VertexArray);
			GL.EnableClientState(All.TextureCoordArray);

			// カリング処理の設定
			GL.Disable((All)EnableCap.CullFace);
			GL.FrontFace((All)FrontFaceDirection.Cw);

			// 描画バッファの設定
			GL.Oes.GenFramebuffers(1, out mFrameBuffer);
			GL.Oes.BindFramebuffer(All.FramebufferOes, mFrameBuffer);

			GL.Oes.GenRenderbuffers(1, out mRenderBuffer);
			GL.Oes.BindRenderbuffer(All.RenderbufferOes, mRenderBuffer);

			GL.Oes.GetRenderbufferParameter(All.RenderbufferOes, All.RenderbufferWidthOes, out mWidth);
			GL.Oes.GetRenderbufferParameter(All.RenderbufferOes, All.RenderbufferHeightOes, out mHeight);

			mContext.RenderBufferStorage((uint)All.RenderbufferOes, layer);
			GL.Oes.FramebufferRenderbuffer(All.FramebufferOes, All.ColorAttachment0Oes, All.RenderbufferOes, mRenderBuffer);

			UIImage image = new UIImage("t_title_logo");  // "t_title_logo"はpngイメージ
			UIImage[] ImageList = new UIImage[1];
			ImageList[0] = image;
			InitTexture(ImageList, 0, 1);
		}

```