asgardius/virtualx-engine
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

newline fixes

Browse source
This commit is contained in:
reduz 2015-10-08 15:00:40 -03:00
parent 3514a87b37
commit aad2bbdb6f
38 changed files with 33297 additions and 33297 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

718
core/io/aes256.cpp
View file

@ -1,359 +1,359 @@
/* /*
* Byte-oriented AES-256 implementation. * Byte-oriented AES-256 implementation.
* All lookup tables replaced with 'on the fly' calculations. * All lookup tables replaced with 'on the fly' calculations.
* *
* Copyright (c) 2007-2009 Ilya O. Levin, http://www.literatecode.com * Copyright (c) 2007-2009 Ilya O. Levin, http://www.literatecode.com
* Other contributors: Hal Finney * Other contributors: Hal Finney
* *
* Permission to use, copy, modify, and distribute this software for any * Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above * purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies. * copyright notice and this permission notice appear in all copies.
* *
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/ */
#include "aes256.h" #include "aes256.h"
#define F(x) (((x)<<1) ^ ((((x)>>7) & 1) * 0x1b)) #define F(x) (((x)<<1) ^ ((((x)>>7) & 1) * 0x1b))
#define FD(x) (((x) >> 1) ^ (((x) & 1) ? 0x8d : 0)) #define FD(x) (((x) >> 1) ^ (((x) & 1) ? 0x8d : 0))
// #define BACK_TO_TABLES // #define BACK_TO_TABLES
#ifdef BACK_TO_TABLES #ifdef BACK_TO_TABLES
const uint8_t sbox[256] = { const uint8_t sbox[256] = {
0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5,
0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76,
0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0,
0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0,
0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc,
0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15,
0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a,
0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75,
0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0,
0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84,
0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b,
0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf,
0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85,
0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8,
0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5,
0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2,
0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17,
0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73,
0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88,
0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb,
0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c,
0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79,
0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9,
0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08,
0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6,
0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a,
0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e,
0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e,
0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94,
0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf,
0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68,
0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16
}; };
const uint8_t sboxinv[256] = { const uint8_t sboxinv[256] = {
0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38,
0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb,
0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87,
0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb,
0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d,
0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e,
0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2,
0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25,
0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16,
0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92,
0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda,
0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84,
0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a,
0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06,
0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02,
0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b,
0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea,
0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73,
0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85,
0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e,
0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89,
0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b,
0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20,
0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4,
0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31,
0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f,
0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d,
0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef,
0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0,
0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61,
0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26,
0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d
}; };
#define rj_sbox(x) sbox[(x)] #define rj_sbox(x) sbox[(x)]
#define rj_sbox_inv(x) sboxinv[(x)] #define rj_sbox_inv(x) sboxinv[(x)]
#else /* tableless subroutines */ #else /* tableless subroutines */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
uint8_t gf_alog(uint8_t x) // calculate anti-logarithm gen 3 uint8_t gf_alog(uint8_t x) // calculate anti-logarithm gen 3
{ {
uint8_t atb = 1, z; uint8_t atb = 1, z;
while (x--) {z = atb; atb <<= 1; if (z & 0x80) atb^= 0x1b; atb ^= z;} while (x--) {z = atb; atb <<= 1; if (z & 0x80) atb^= 0x1b; atb ^= z;}
return atb; return atb;
} /* gf_alog */ } /* gf_alog */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
uint8_t gf_log(uint8_t x) // calculate logarithm gen 3 uint8_t gf_log(uint8_t x) // calculate logarithm gen 3
{ {
uint8_t atb = 1, i = 0, z; uint8_t atb = 1, i = 0, z;
do { do {
if (atb == x) break; if (atb == x) break;
z = atb; atb <<= 1; if (z & 0x80) atb^= 0x1b; atb ^= z; z = atb; atb <<= 1; if (z & 0x80) atb^= 0x1b; atb ^= z;
} while (++i > 0); } while (++i > 0);
return i; return i;
} /* gf_log */ } /* gf_log */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
uint8_t gf_mulinv(uint8_t x) // calculate multiplicative inverse uint8_t gf_mulinv(uint8_t x) // calculate multiplicative inverse
{ {
return (x) ? gf_alog(255 - gf_log(x)) : 0; return (x) ? gf_alog(255 - gf_log(x)) : 0;
} /* gf_mulinv */ } /* gf_mulinv */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
uint8_t rj_sbox(uint8_t x) uint8_t rj_sbox(uint8_t x)
{ {
uint8_t y, sb; uint8_t y, sb;
sb = y = gf_mulinv(x); sb = y = gf_mulinv(x);
y = (y<<1)|(y>>7); sb ^= y; y = (y<<1)|(y>>7); sb ^= y; y = (y<<1)|(y>>7); sb ^= y; y = (y<<1)|(y>>7); sb ^= y;
y = (y<<1)|(y>>7); sb ^= y; y = (y<<1)|(y>>7); sb ^= y; y = (y<<1)|(y>>7); sb ^= y; y = (y<<1)|(y>>7); sb ^= y;
return (sb ^ 0x63); return (sb ^ 0x63);
} /* rj_sbox */ } /* rj_sbox */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
uint8_t rj_sbox_inv(uint8_t x) uint8_t rj_sbox_inv(uint8_t x)
{ {
uint8_t y, sb; uint8_t y, sb;
y = x ^ 0x63; y = x ^ 0x63;
sb = y = (y<<1)|(y>>7); sb = y = (y<<1)|(y>>7);
y = (y<<2)|(y>>6); sb ^= y; y = (y<<3)|(y>>5); sb ^= y; y = (y<<2)|(y>>6); sb ^= y; y = (y<<3)|(y>>5); sb ^= y;
return gf_mulinv(sb); return gf_mulinv(sb);
} /* rj_sbox_inv */ } /* rj_sbox_inv */
#endif #endif
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
uint8_t rj_xtime(uint8_t x) uint8_t rj_xtime(uint8_t x)
{ {
return (x & 0x80) ? ((x << 1) ^ 0x1b) : (x << 1); return (x & 0x80) ? ((x << 1) ^ 0x1b) : (x << 1);
} /* rj_xtime */ } /* rj_xtime */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
void aes_subBytes(uint8_t *buf) void aes_subBytes(uint8_t *buf)
{ {
register uint8_t i = 16; register uint8_t i = 16;
while (i--) buf[i] = rj_sbox(buf[i]); while (i--) buf[i] = rj_sbox(buf[i]);
} /* aes_subBytes */ } /* aes_subBytes */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
void aes_subBytes_inv(uint8_t *buf) void aes_subBytes_inv(uint8_t *buf)
{ {
register uint8_t i = 16; register uint8_t i = 16;
while (i--) buf[i] = rj_sbox_inv(buf[i]); while (i--) buf[i] = rj_sbox_inv(buf[i]);
} /* aes_subBytes_inv */ } /* aes_subBytes_inv */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
void aes_addRoundKey(uint8_t *buf, uint8_t *key) void aes_addRoundKey(uint8_t *buf, uint8_t *key)
{ {
register uint8_t i = 16; register uint8_t i = 16;
while (i--) buf[i] ^= key[i]; while (i--) buf[i] ^= key[i];
} /* aes_addRoundKey */ } /* aes_addRoundKey */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
void aes_addRoundKey_cpy(uint8_t *buf, uint8_t *key, uint8_t *cpk) void aes_addRoundKey_cpy(uint8_t *buf, uint8_t *key, uint8_t *cpk)
{ {
register uint8_t i = 16; register uint8_t i = 16;
while (i--) buf[i] ^= (cpk[i] = key[i]), cpk[16+i] = key[16 + i]; while (i--) buf[i] ^= (cpk[i] = key[i]), cpk[16+i] = key[16 + i];
} /* aes_addRoundKey_cpy */ } /* aes_addRoundKey_cpy */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
void aes_shiftRows(uint8_t *buf) void aes_shiftRows(uint8_t *buf)
{ {
register uint8_t i, j; /* to make it potentially parallelable :) */ register uint8_t i, j; /* to make it potentially parallelable :) */
i = buf[1]; buf[1] = buf[5]; buf[5] = buf[9]; buf[9] = buf[13]; buf[13] = i; i = buf[1]; buf[1] = buf[5]; buf[5] = buf[9]; buf[9] = buf[13]; buf[13] = i;
i = buf[10]; buf[10] = buf[2]; buf[2] = i; i = buf[10]; buf[10] = buf[2]; buf[2] = i;
j = buf[3]; buf[3] = buf[15]; buf[15] = buf[11]; buf[11] = buf[7]; buf[7] = j; j = buf[3]; buf[3] = buf[15]; buf[15] = buf[11]; buf[11] = buf[7]; buf[7] = j;
j = buf[14]; buf[14] = buf[6]; buf[6] = j; j = buf[14]; buf[14] = buf[6]; buf[6] = j;
} /* aes_shiftRows */ } /* aes_shiftRows */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
void aes_shiftRows_inv(uint8_t *buf) void aes_shiftRows_inv(uint8_t *buf)
{ {
register uint8_t i, j; /* same as above :) */ register uint8_t i, j; /* same as above :) */
i = buf[1]; buf[1] = buf[13]; buf[13] = buf[9]; buf[9] = buf[5]; buf[5] = i; i = buf[1]; buf[1] = buf[13]; buf[13] = buf[9]; buf[9] = buf[5]; buf[5] = i;
i = buf[2]; buf[2] = buf[10]; buf[10] = i; i = buf[2]; buf[2] = buf[10]; buf[10] = i;
j = buf[3]; buf[3] = buf[7]; buf[7] = buf[11]; buf[11] = buf[15]; buf[15] = j; j = buf[3]; buf[3] = buf[7]; buf[7] = buf[11]; buf[11] = buf[15]; buf[15] = j;
j = buf[6]; buf[6] = buf[14]; buf[14] = j; j = buf[6]; buf[6] = buf[14]; buf[14] = j;
} /* aes_shiftRows_inv */ } /* aes_shiftRows_inv */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
void aes_mixColumns(uint8_t *buf) void aes_mixColumns(uint8_t *buf)
{ {
register uint8_t i, a, b, c, d, e; register uint8_t i, a, b, c, d, e;
for (i = 0; i < 16; i += 4) for (i = 0; i < 16; i += 4)
{ {
a = buf[i]; b = buf[i + 1]; c = buf[i + 2]; d = buf[i + 3]; a = buf[i]; b = buf[i + 1]; c = buf[i + 2]; d = buf[i + 3];
e = a ^ b ^ c ^ d; e = a ^ b ^ c ^ d;
buf[i] ^= e ^ rj_xtime(a^b); buf[i+1] ^= e ^ rj_xtime(b^c); buf[i] ^= e ^ rj_xtime(a^b); buf[i+1] ^= e ^ rj_xtime(b^c);
buf[i+2] ^= e ^ rj_xtime(c^d); buf[i+3] ^= e ^ rj_xtime(d^a); buf[i+2] ^= e ^ rj_xtime(c^d); buf[i+3] ^= e ^ rj_xtime(d^a);
} }
} /* aes_mixColumns */ } /* aes_mixColumns */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
void aes_mixColumns_inv(uint8_t *buf) void aes_mixColumns_inv(uint8_t *buf)
{ {
register uint8_t i, a, b, c, d, e, x, y, z; register uint8_t i, a, b, c, d, e, x, y, z;
for (i = 0; i < 16; i += 4) for (i = 0; i < 16; i += 4)
{ {
a = buf[i]; b = buf[i + 1]; c = buf[i + 2]; d = buf[i + 3]; a = buf[i]; b = buf[i + 1]; c = buf[i + 2]; d = buf[i + 3];
e = a ^ b ^ c ^ d; e = a ^ b ^ c ^ d;
z = rj_xtime(e); z = rj_xtime(e);
x = e ^ rj_xtime(rj_xtime(z^a^c)); y = e ^ rj_xtime(rj_xtime(z^b^d)); x = e ^ rj_xtime(rj_xtime(z^a^c)); y = e ^ rj_xtime(rj_xtime(z^b^d));
buf[i] ^= x ^ rj_xtime(a^b); buf[i+1] ^= y ^ rj_xtime(b^c); buf[i] ^= x ^ rj_xtime(a^b); buf[i+1] ^= y ^ rj_xtime(b^c);
buf[i+2] ^= x ^ rj_xtime(c^d); buf[i+3] ^= y ^ rj_xtime(d^a); buf[i+2] ^= x ^ rj_xtime(c^d); buf[i+3] ^= y ^ rj_xtime(d^a);
} }
} /* aes_mixColumns_inv */ } /* aes_mixColumns_inv */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
void aes_expandEncKey(uint8_t *k, uint8_t *rc) void aes_expandEncKey(uint8_t *k, uint8_t *rc)
{ {
register uint8_t i; register uint8_t i;
k[0] ^= rj_sbox(k[29]) ^ (*rc); k[0] ^= rj_sbox(k[29]) ^ (*rc);
k[1] ^= rj_sbox(k[30]); k[1] ^= rj_sbox(k[30]);
k[2] ^= rj_sbox(k[31]); k[2] ^= rj_sbox(k[31]);
k[3] ^= rj_sbox(k[28]); k[3] ^= rj_sbox(k[28]);
*rc = F( *rc); *rc = F( *rc);
for(i = 4; i < 16; i += 4) k[i] ^= k[i-4], k[i+1] ^= k[i-3], for(i = 4; i < 16; i += 4) k[i] ^= k[i-4], k[i+1] ^= k[i-3],
k[i+2] ^= k[i-2], k[i+3] ^= k[i-1]; k[i+2] ^= k[i-2], k[i+3] ^= k[i-1];
k[16] ^= rj_sbox(k[12]); k[16] ^= rj_sbox(k[12]);
k[17] ^= rj_sbox(k[13]); k[17] ^= rj_sbox(k[13]);
k[18] ^= rj_sbox(k[14]); k[18] ^= rj_sbox(k[14]);
k[19] ^= rj_sbox(k[15]); k[19] ^= rj_sbox(k[15]);
for(i = 20; i < 32; i += 4) k[i] ^= k[i-4], k[i+1] ^= k[i-3], for(i = 20; i < 32; i += 4) k[i] ^= k[i-4], k[i+1] ^= k[i-3],
k[i+2] ^= k[i-2], k[i+3] ^= k[i-1]; k[i+2] ^= k[i-2], k[i+3] ^= k[i-1];
} /* aes_expandEncKey */ } /* aes_expandEncKey */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
void aes_expandDecKey(uint8_t *k, uint8_t *rc) void aes_expandDecKey(uint8_t *k, uint8_t *rc)
{ {
uint8_t i; uint8_t i;
for(i = 28; i > 16; i -= 4) k[i+0] ^= k[i-4], k[i+1] ^= k[i-3], for(i = 28; i > 16; i -= 4) k[i+0] ^= k[i-4], k[i+1] ^= k[i-3],
k[i+2] ^= k[i-2], k[i+3] ^= k[i-1]; k[i+2] ^= k[i-2], k[i+3] ^= k[i-1];
k[16] ^= rj_sbox(k[12]); k[16] ^= rj_sbox(k[12]);
k[17] ^= rj_sbox(k[13]); k[17] ^= rj_sbox(k[13]);
k[18] ^= rj_sbox(k[14]); k[18] ^= rj_sbox(k[14]);
k[19] ^= rj_sbox(k[15]); k[19] ^= rj_sbox(k[15]);
for(i = 12; i > 0; i -= 4) k[i+0] ^= k[i-4], k[i+1] ^= k[i-3], for(i = 12; i > 0; i -= 4) k[i+0] ^= k[i-4], k[i+1] ^= k[i-3],
k[i+2] ^= k[i-2], k[i+3] ^= k[i-1]; k[i+2] ^= k[i-2], k[i+3] ^= k[i-1];
*rc = FD(*rc); *rc = FD(*rc);
k[0] ^= rj_sbox(k[29]) ^ (*rc); k[0] ^= rj_sbox(k[29]) ^ (*rc);
k[1] ^= rj_sbox(k[30]); k[1] ^= rj_sbox(k[30]);
k[2] ^= rj_sbox(k[31]); k[2] ^= rj_sbox(k[31]);
k[3] ^= rj_sbox(k[28]); k[3] ^= rj_sbox(k[28]);
} /* aes_expandDecKey */ } /* aes_expandDecKey */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
void aes256_init(aes256_context *ctx, uint8_t *k) void aes256_init(aes256_context *ctx, uint8_t *k)
{ {
uint8_t rcon = 1; uint8_t rcon = 1;
register uint8_t i; register uint8_t i;
for (i = 0; i < sizeof(ctx->key); i++) ctx->enckey[i] = ctx->deckey[i] = k[i]; for (i = 0; i < sizeof(ctx->key); i++) ctx->enckey[i] = ctx->deckey[i] = k[i];
for (i = 8;--i;) aes_expandEncKey(ctx->deckey, &rcon); for (i = 8;--i;) aes_expandEncKey(ctx->deckey, &rcon);
} /* aes256_init */ } /* aes256_init */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
void aes256_done(aes256_context *ctx) void aes256_done(aes256_context *ctx)
{ {
register uint8_t i; register uint8_t i;
for (i = 0; i < sizeof(ctx->key); i++) for (i = 0; i < sizeof(ctx->key); i++)
ctx->key[i] = ctx->enckey[i] = ctx->deckey[i] = 0; ctx->key[i] = ctx->enckey[i] = ctx->deckey[i] = 0;
} /* aes256_done */ } /* aes256_done */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
void aes256_encrypt_ecb(aes256_context *ctx, uint8_t *buf) void aes256_encrypt_ecb(aes256_context *ctx, uint8_t *buf)
{ {
uint8_t i, rcon; uint8_t i, rcon;
aes_addRoundKey_cpy(buf, ctx->enckey, ctx->key); aes_addRoundKey_cpy(buf, ctx->enckey, ctx->key);
for(i = 1, rcon = 1; i < 14; ++i) for(i = 1, rcon = 1; i < 14; ++i)
{ {
aes_subBytes(buf); aes_subBytes(buf);
aes_shiftRows(buf); aes_shiftRows(buf);
aes_mixColumns(buf); aes_mixColumns(buf);
if( i & 1 ) aes_addRoundKey( buf, &ctx->key[16]); if( i & 1 ) aes_addRoundKey( buf, &ctx->key[16]);
else aes_expandEncKey(ctx->key, &rcon), aes_addRoundKey(buf, ctx->key); else aes_expandEncKey(ctx->key, &rcon), aes_addRoundKey(buf, ctx->key);
} }
aes_subBytes(buf); aes_subBytes(buf);
aes_shiftRows(buf); aes_shiftRows(buf);
aes_expandEncKey(ctx->key, &rcon); aes_expandEncKey(ctx->key, &rcon);
aes_addRoundKey(buf, ctx->key); aes_addRoundKey(buf, ctx->key);
} /* aes256_encrypt */ } /* aes256_encrypt */
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
void aes256_decrypt_ecb(aes256_context *ctx, uint8_t *buf) void aes256_decrypt_ecb(aes256_context *ctx, uint8_t *buf)
{ {
uint8_t i, rcon; uint8_t i, rcon;
aes_addRoundKey_cpy(buf, ctx->deckey, ctx->key); aes_addRoundKey_cpy(buf, ctx->deckey, ctx->key);
aes_shiftRows_inv(buf); aes_shiftRows_inv(buf);
aes_subBytes_inv(buf); aes_subBytes_inv(buf);
for (i = 14, rcon = 0x80; --i;) for (i = 14, rcon = 0x80; --i;)
{ {
if( ( i & 1 ) ) if( ( i & 1 ) )
{ {
aes_expandDecKey(ctx->key, &rcon); aes_expandDecKey(ctx->key, &rcon);
aes_addRoundKey(buf, &ctx->key[16]); aes_addRoundKey(buf, &ctx->key[16]);
} }
else aes_addRoundKey(buf, ctx->key); else aes_addRoundKey(buf, ctx->key);
aes_mixColumns_inv(buf); aes_mixColumns_inv(buf);
aes_shiftRows_inv(buf); aes_shiftRows_inv(buf);
aes_subBytes_inv(buf); aes_subBytes_inv(buf);
} }
aes_addRoundKey( buf, ctx->key); aes_addRoundKey( buf, ctx->key);
} /* aes256_decrypt */ } /* aes256_decrypt */

92
core/io/aes256.h
View file

@ -1,46 +1,46 @@
/* /*
* Byte-oriented AES-256 implementation. * Byte-oriented AES-256 implementation.
* All lookup tables replaced with 'on the fly' calculations. * All lookup tables replaced with 'on the fly' calculations.
* *
* Copyright (c) 2007-2009 Ilya O. Levin, http://www.literatecode.com * Copyright (c) 2007-2009 Ilya O. Levin, http://www.literatecode.com
* Other contributors: Hal Finney * Other contributors: Hal Finney
* *
* Permission to use, copy, modify, and distribute this software for any * Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above * purpose with or without fee is hereby granted, provided that the above
* copyright notice and this permission notice appear in all copies. * copyright notice and this permission notice appear in all copies.
* *
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/ */
#ifndef AES_256_H #ifndef AES_256_H
#define AES_256_H #define AES_256_H
#include "typedefs.h" #include "typedefs.h"
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
typedef struct { typedef struct {
uint8_t key[32]; uint8_t key[32];
uint8_t enckey[32]; uint8_t enckey[32];
uint8_t deckey[32]; uint8_t deckey[32];
} aes256_context; } aes256_context;
void aes256_init(aes256_context *, uint8_t * /* key */); void aes256_init(aes256_context *, uint8_t * /* key */);
void aes256_done(aes256_context *); void aes256_done(aes256_context *);
void aes256_encrypt_ecb(aes256_context *, uint8_t * /* plaintext */); void aes256_encrypt_ecb(aes256_context *, uint8_t * /* plaintext */);
void aes256_decrypt_ecb(aes256_context *, uint8_t * /* cipertext */); void aes256_decrypt_ecb(aes256_context *, uint8_t * /* cipertext */);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif

4908
drivers/etc1/rg_etc1.cpp
View file

File diff suppressed because it is too large Load diff

152
drivers/etc1/rg_etc1.h
View file

@ -1,76 +1,76 @@
// File: rg_etc1.h - Fast, high quality ETC1 block packer/unpacker - Rich Geldreich <richgel99@gmail.com> // File: rg_etc1.h - Fast, high quality ETC1 block packer/unpacker - Rich Geldreich <richgel99@gmail.com>
// Please see ZLIB license at the end of this file. // Please see ZLIB license at the end of this file.
#pragma once #pragma once
namespace rg_etc1 namespace rg_etc1
{ {
// Unpacks an 8-byte ETC1 compressed block to a block of 4x4 32bpp RGBA pixels. // Unpacks an 8-byte ETC1 compressed block to a block of 4x4 32bpp RGBA pixels.
// Returns false if the block is invalid. Invalid blocks will still be unpacked with clamping. // Returns false if the block is invalid. Invalid blocks will still be unpacked with clamping.
// This function is thread safe, and does not dynamically allocate any memory. // This function is thread safe, and does not dynamically allocate any memory.
// If preserve_alpha is true, the alpha channel of the destination pixels will not be overwritten. Otherwise, alpha will be set to 255. // If preserve_alpha is true, the alpha channel of the destination pixels will not be overwritten. Otherwise, alpha will be set to 255.
bool unpack_etc1_block(const void *pETC1_block, unsigned int* pDst_pixels_rgba, bool preserve_alpha = false); bool unpack_etc1_block(const void *pETC1_block, unsigned int* pDst_pixels_rgba, bool preserve_alpha = false);
// Quality setting = the higher the quality, the slower. // Quality setting = the higher the quality, the slower.
// To pack large textures, it is highly recommended to call pack_etc1_block() in parallel, on different blocks, from multiple threads (particularly when using cHighQuality). // To pack large textures, it is highly recommended to call pack_etc1_block() in parallel, on different blocks, from multiple threads (particularly when using cHighQuality).
enum etc1_quality enum etc1_quality
{ {
cLowQuality, cLowQuality,
cMediumQuality, cMediumQuality,
cHighQuality, cHighQuality,
}; };
struct etc1_pack_params struct etc1_pack_params
{ {
etc1_quality m_quality; etc1_quality m_quality;
bool m_dithering; bool m_dithering;
inline etc1_pack_params() inline etc1_pack_params()
{ {
clear(); clear();
} }
void clear() void clear()
{ {
m_quality = cHighQuality; m_quality = cHighQuality;
m_dithering = false; m_dithering = false;
} }
}; };
// Important: pack_etc1_block_init() must be called before calling pack_etc1_block(). // Important: pack_etc1_block_init() must be called before calling pack_etc1_block().
void pack_etc1_block_init(); void pack_etc1_block_init();
// Packs a 4x4 block of 32bpp RGBA pixels to an 8-byte ETC1 block. // Packs a 4x4 block of 32bpp RGBA pixels to an 8-byte ETC1 block.
// 32-bit RGBA pixels must always be arranged as (R,G,B,A) (R first, A last) in memory, independent of platform endianness. A should always be 255. // 32-bit RGBA pixels must always be arranged as (R,G,B,A) (R first, A last) in memory, independent of platform endianness. A should always be 255.
// Returns squared error of result. // Returns squared error of result.
// This function is thread safe, and does not dynamically allocate any memory. // This function is thread safe, and does not dynamically allocate any memory.
// pack_etc1_block() does not currently support "perceptual" colorspace metrics - it primarily optimizes for RGB RMSE. // pack_etc1_block() does not currently support "perceptual" colorspace metrics - it primarily optimizes for RGB RMSE.
unsigned int pack_etc1_block(void* pETC1_block, const unsigned int* pSrc_pixels_rgba, etc1_pack_params& pack_params); unsigned int pack_etc1_block(void* pETC1_block, const unsigned int* pSrc_pixels_rgba, etc1_pack_params& pack_params);
} // namespace rg_etc1 } // namespace rg_etc1
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------
// //
// rg_etc1 uses the ZLIB license: // rg_etc1 uses the ZLIB license:
// http://opensource.org/licenses/Zlib // http://opensource.org/licenses/Zlib
// //
// Copyright (c) 2012 Rich Geldreich // Copyright (c) 2012 Rich Geldreich
// //
// This software is provided 'as-is', without any express or implied // This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages // warranty. In no event will the authors be held liable for any damages
// arising from the use of this software. // arising from the use of this software.
// //
// Permission is granted to anyone to use this software for any purpose, // Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it // including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions: // freely, subject to the following restrictions:
// //
// 1. The origin of this software must not be misrepresented; you must not // 1. The origin of this software must not be misrepresented; you must not
// claim that you wrote the original software. If you use this software // claim that you wrote the original software. If you use this software
// in a product, an acknowledgment in the product documentation would be // in a product, an acknowledgment in the product documentation would be
// appreciated but is not required. // appreciated but is not required.
// //
// 2. Altered source versions must be plainly marked as such, and must not be // 2. Altered source versions must be plainly marked as such, and must not be
// misrepresented as being the original software. // misrepresented as being the original software.
// //
// 3. This notice may not be removed or altered from any source distribution. // 3. This notice may not be removed or altered from any source distribution.
// //
//------------------------------------------------------------------------------ //------------------------------------------------------------------------------

11628
drivers/nedmalloc/malloc.c.h
View file

File diff suppressed because it is too large Load diff

2934
drivers/nedmalloc/nedmalloc.cpp
View file

File diff suppressed because it is too large Load diff

604
drivers/nedmalloc/nedmalloc.h
View file

@ -1,302 +1,302 @@
#ifdef NEDMALLOC_ENABLED #ifdef NEDMALLOC_ENABLED
/* nedalloc, an alternative malloc implementation for multiple threads without /* nedalloc, an alternative malloc implementation for multiple threads without
lock contention based on dlmalloc v2.8.3. (C) 2005-2009 Niall Douglas lock contention based on dlmalloc v2.8.3. (C) 2005-2009 Niall Douglas
Boost Software License - Version 1.0 - August 17th, 2003 Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute, this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following: do so, all subject to the following:
The copyright notices in the Software and this entire statement, including The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer, the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by works are solely in the form of machine-executable object code generated by
a source language processor. a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE. DEALINGS IN THE SOFTWARE.
*/ */
#ifndef NEDMALLOC_H #ifndef NEDMALLOC_H
#define NEDMALLOC_H #define NEDMALLOC_H
#include "typedefs.h" #include "typedefs.h"
#define MALLOC_ALIGNMENT DEFAULT_ALIGNMENT #define MALLOC_ALIGNMENT DEFAULT_ALIGNMENT
#ifdef PSP_ENABLED #ifdef PSP_ENABLED
#define USE_LOCKS 0 #define USE_LOCKS 0
#define HAVE_MMAP 0 #define HAVE_MMAP 0
#endif #endif
/* See malloc.c.h for what each function does. /* See malloc.c.h for what each function does.
REPLACE_SYSTEM_ALLOCATOR on POSIX causes nedalloc's functions to be called REPLACE_SYSTEM_ALLOCATOR on POSIX causes nedalloc's functions to be called
malloc, free etc. instead of nedmalloc, nedfree etc. You may or may not want malloc, free etc. instead of nedmalloc, nedfree etc. You may or may not want
this. On Windows it causes nedmalloc to patch all loaded DLLs and binaries this. On Windows it causes nedmalloc to patch all loaded DLLs and binaries
to replace usage of the system allocator. to replace usage of the system allocator.
NO_NED_NAMESPACE prevents the functions from being defined in the nedalloc NO_NED_NAMESPACE prevents the functions from being defined in the nedalloc
namespace when in C++ (uses the global namespace instead). namespace when in C++ (uses the global namespace instead).
NEDMALLOCEXTSPEC can be defined to be __declspec(dllexport) or NEDMALLOCEXTSPEC can be defined to be __declspec(dllexport) or
__attribute__ ((visibility("default"))) or whatever you like. It defaults __attribute__ ((visibility("default"))) or whatever you like. It defaults
to extern unless NEDMALLOC_DLL_EXPORTS is set as it would be when building to extern unless NEDMALLOC_DLL_EXPORTS is set as it would be when building
nedmalloc.dll. nedmalloc.dll.
USE_LOCKS can be 2 if you want to define your own MLOCK_T, INITIAL_LOCK, USE_LOCKS can be 2 if you want to define your own MLOCK_T, INITIAL_LOCK,
ACQUIRE_LOCK, RELEASE_LOCK, TRY_LOCK, IS_LOCKED and NULL_LOCK_INITIALIZER. ACQUIRE_LOCK, RELEASE_LOCK, TRY_LOCK, IS_LOCKED and NULL_LOCK_INITIALIZER.
NEDMALLOC_DEBUG can be defined to cause DEBUG to be set differently for nedmalloc NEDMALLOC_DEBUG can be defined to cause DEBUG to be set differently for nedmalloc
than for the rest of the build. Remember to set NDEBUG to disable all assertion than for the rest of the build. Remember to set NDEBUG to disable all assertion
checking too. checking too.
USE_MAGIC_HEADERS causes nedalloc to allocate an extra three sizeof(size_t) USE_MAGIC_HEADERS causes nedalloc to allocate an extra three sizeof(size_t)
to each block. nedpfree() and nedprealloc() can then automagically know when to each block. nedpfree() and nedprealloc() can then automagically know when
to free a system allocated block. Enabling this typically adds 20-50% to to free a system allocated block. Enabling this typically adds 20-50% to
application memory usage. application memory usage.
ENABLE_TOLERANT_NEDMALLOC is automatically turned on if REPLACE_SYSTEM_ALLOCATOR ENABLE_TOLERANT_NEDMALLOC is automatically turned on if REPLACE_SYSTEM_ALLOCATOR
is set or the Windows DLL is being built. This causes nedmalloc to detect when a is set or the Windows DLL is being built. This causes nedmalloc to detect when a
system allocator block is passed to it and to handle it appropriately. Note that system allocator block is passed to it and to handle it appropriately. Note that
without USE_MAGIC_HEADERS there is a very tiny chance that nedmalloc will segfault without USE_MAGIC_HEADERS there is a very tiny chance that nedmalloc will segfault
on non-Windows builds (it uses Win32 SEH to trap segfaults on Windows and there on non-Windows builds (it uses Win32 SEH to trap segfaults on Windows and there
is no comparable system on POSIX). is no comparable system on POSIX).
USE_ALLOCATOR can be one of these settings (it defaults to 1): USE_ALLOCATOR can be one of these settings (it defaults to 1):
0: System allocator (nedmalloc now simply acts as a threadcache). 0: System allocator (nedmalloc now simply acts as a threadcache).
WARNING: Intended for DEBUG USE ONLY - not all functions work correctly. WARNING: Intended for DEBUG USE ONLY - not all functions work correctly.
1: dlmalloc 1: dlmalloc
ENABLE_LARGE_PAGES enables support for requesting memory from the system in large ENABLE_LARGE_PAGES enables support for requesting memory from the system in large
(typically >=2Mb) pages if the host OS supports this. These occupy just a single (typically >=2Mb) pages if the host OS supports this. These occupy just a single
TLB entry and can significantly improve performance in large working set applications. TLB entry and can significantly improve performance in large working set applications.
ENABLE_FAST_HEAP_DETECTION enables special logic to detect blocks allocated ENABLE_FAST_HEAP_DETECTION enables special logic to detect blocks allocated
by the system heap. This avoids 1.5%-2% overhead when checking for non-nedmalloc by the system heap. This avoids 1.5%-2% overhead when checking for non-nedmalloc
blocks, but it assumes that the NT and glibc heaps function in a very specific blocks, but it assumes that the NT and glibc heaps function in a very specific
fashion which may not hold true across OS upgrades. fashion which may not hold true across OS upgrades.
*/ */
#include <stddef.h> /* for size_t */ #include <stddef.h> /* for size_t */
#ifndef NEDMALLOCEXTSPEC #ifndef NEDMALLOCEXTSPEC
#ifdef NEDMALLOC_DLL_EXPORTS #ifdef NEDMALLOC_DLL_EXPORTS
#ifdef WIN32 #ifdef WIN32
#define NEDMALLOCEXTSPEC extern __declspec(dllexport) #define NEDMALLOCEXTSPEC extern __declspec(dllexport)
#elif defined(__GNUC__) #elif defined(__GNUC__)
#define NEDMALLOCEXTSPEC extern __attribute__ ((visibility("default"))) #define NEDMALLOCEXTSPEC extern __attribute__ ((visibility("default")))
#endif #endif
#ifndef ENABLE_TOLERANT_NEDMALLOC #ifndef ENABLE_TOLERANT_NEDMALLOC
#define ENABLE_TOLERANT_NEDMALLOC 1 #define ENABLE_TOLERANT_NEDMALLOC 1
#endif #endif
#else #else
#define NEDMALLOCEXTSPEC extern #define NEDMALLOCEXTSPEC extern
#endif #endif
#endif #endif
#if __STDC_VERSION__ >= 199901L /* C99 or better */ #if __STDC_VERSION__ >= 199901L /* C99 or better */
#define RESTRICT restrict #define RESTRICT restrict
#else #else
#if defined(_MSC_VER) && _MSC_VER>=1400 #if defined(_MSC_VER) && _MSC_VER>=1400
#define RESTRICT __restrict #define RESTRICT __restrict
#endif #endif
#ifdef __GNUC__ #ifdef __GNUC__
#define RESTRICT __restrict #define RESTRICT __restrict
#endif #endif
#endif #endif
#ifndef RESTRICT #ifndef RESTRICT
#define RESTRICT #define RESTRICT
#endif #endif
#if defined(_MSC_VER) && _MSC_VER>=1400 #if defined(_MSC_VER) && _MSC_VER>=1400
#define NEDMALLOCPTRATTR __declspec(restrict) #define NEDMALLOCPTRATTR __declspec(restrict)
#define NEDMALLOCNOALIASATTR __declspec(noalias) #define NEDMALLOCNOALIASATTR __declspec(noalias)
#endif #endif
#ifdef __GNUC__ #ifdef __GNUC__
#define NEDMALLOCPTRATTR __attribute__ ((malloc)) #define NEDMALLOCPTRATTR __attribute__ ((malloc))
#endif #endif
#ifndef NEDMALLOCPTRATTR #ifndef NEDMALLOCPTRATTR
#define NEDMALLOCPTRATTR #define NEDMALLOCPTRATTR
#endif #endif
#ifndef NEDMALLOCNOALIASATTR #ifndef NEDMALLOCNOALIASATTR
#define NEDMALLOCNOALIASATTR #define NEDMALLOCNOALIASATTR
#endif #endif
#ifndef USE_MAGIC_HEADERS #ifndef USE_MAGIC_HEADERS
#define USE_MAGIC_HEADERS 0 #define USE_MAGIC_HEADERS 0
#endif #endif
#ifndef USE_ALLOCATOR #ifndef USE_ALLOCATOR
#define USE_ALLOCATOR 1 /* dlmalloc */ #define USE_ALLOCATOR 1 /* dlmalloc */
#endif #endif
#if !USE_ALLOCATOR && !USE_MAGIC_HEADERS #if !USE_ALLOCATOR && !USE_MAGIC_HEADERS
#error If you are using the system allocator then you MUST use magic headers #error If you are using the system allocator then you MUST use magic headers
#endif #endif
#ifdef REPLACE_SYSTEM_ALLOCATOR #ifdef REPLACE_SYSTEM_ALLOCATOR
#if USE_ALLOCATOR==0 #if USE_ALLOCATOR==0
#error Cannot combine using the system allocator with replacing the system allocator #error Cannot combine using the system allocator with replacing the system allocator
#endif #endif
#ifndef ENABLE_TOLERANT_NEDMALLOC #ifndef ENABLE_TOLERANT_NEDMALLOC
#define ENABLE_TOLERANT_NEDMALLOC 1 #define ENABLE_TOLERANT_NEDMALLOC 1
#endif #endif
#ifndef WIN32 /* We have a dedicated patcher for Windows */ #ifndef WIN32 /* We have a dedicated patcher for Windows */
#define nedmalloc malloc #define nedmalloc malloc
#define nedcalloc calloc #define nedcalloc calloc
#define nedrealloc realloc #define nedrealloc realloc
#define nedfree free #define nedfree free
#define nedmemalign memalign #define nedmemalign memalign
#define nedmallinfo mallinfo #define nedmallinfo mallinfo
#define nedmallopt mallopt #define nedmallopt mallopt
#define nedmalloc_trim malloc_trim #define nedmalloc_trim malloc_trim
#define nedmalloc_stats malloc_stats #define nedmalloc_stats malloc_stats
#define nedmalloc_footprint malloc_footprint #define nedmalloc_footprint malloc_footprint
#define nedindependent_calloc independent_calloc #define nedindependent_calloc independent_calloc
#define nedindependent_comalloc independent_comalloc #define nedindependent_comalloc independent_comalloc
#ifdef _MSC_VER #ifdef _MSC_VER
#define nedblksize _msize #define nedblksize _msize
#endif #endif
#endif #endif
#endif #endif
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#endif #endif
struct nedmallinfo { struct nedmallinfo {
size_t arena; /* non-mmapped space allocated from system */ size_t arena; /* non-mmapped space allocated from system */
size_t ordblks; /* number of free chunks */ size_t ordblks; /* number of free chunks */
size_t smblks; /* always 0 */ size_t smblks; /* always 0 */
size_t hblks; /* always 0 */ size_t hblks; /* always 0 */
size_t hblkhd; /* space in mmapped regions */ size_t hblkhd; /* space in mmapped regions */
size_t usmblks; /* maximum total allocated space */ size_t usmblks; /* maximum total allocated space */
size_t fsmblks; /* always 0 */ size_t fsmblks; /* always 0 */
size_t uordblks; /* total allocated space */ size_t uordblks; /* total allocated space */
size_t fordblks; /* total free space */ size_t fordblks; /* total free space */
size_t keepcost; /* releasable (via malloc_trim) space */ size_t keepcost; /* releasable (via malloc_trim) space */
}; };
#if defined(__cplusplus) #if defined(__cplusplus)
} }
#endif #endif
#if defined(__cplusplus) #if defined(__cplusplus)
#if !defined(NO_NED_NAMESPACE) #if !defined(NO_NED_NAMESPACE)
namespace nedalloc { namespace nedalloc {
#else #else
extern "C" { extern "C" {
#endif #endif
#define THROWSPEC throw() #define THROWSPEC throw()
#else #else
#define THROWSPEC #define THROWSPEC
#endif #endif
/* These are the global functions */ /* These are the global functions */
/* Gets the usable size of an allocated block. Note this will always be bigger than what was /* Gets the usable size of an allocated block. Note this will always be bigger than what was
asked for due to rounding etc. Optionally returns 1 in isforeign if the block came from the asked for due to rounding etc. Optionally returns 1 in isforeign if the block came from the
system allocator - note that there is a small (>0.01%) but real chance of segfault on non-Windows system allocator - note that there is a small (>0.01%) but real chance of segfault on non-Windows
systems when passing non-nedmalloc blocks if you don't use USE_MAGIC_HEADERS. systems when passing non-nedmalloc blocks if you don't use USE_MAGIC_HEADERS.
*/ */
NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR size_t nedblksize(int *RESTRICT isforeign, void *RESTRICT mem) THROWSPEC; NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR size_t nedblksize(int *RESTRICT isforeign, void *RESTRICT mem) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR void nedsetvalue(void *v) THROWSPEC; NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR void nedsetvalue(void *v) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedmalloc(size_t size) THROWSPEC; NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedmalloc(size_t size) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedcalloc(size_t no, size_t size) THROWSPEC; NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedcalloc(size_t no, size_t size) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedrealloc(void *mem, size_t size) THROWSPEC; NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedrealloc(void *mem, size_t size) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR void nedfree(void *mem) THROWSPEC; NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR void nedfree(void *mem) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedmemalign(size_t alignment, size_t bytes) THROWSPEC; NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void * nedmemalign(size_t alignment, size_t bytes) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR struct nedmallinfo nedmallinfo(void) THROWSPEC; NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR struct nedmallinfo nedmallinfo(void) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR int nedmallopt(int parno, int value) THROWSPEC; NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR int nedmallopt(int parno, int value) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR void* nedmalloc_internals(size_t *granularity, size_t *magic) THROWSPEC; NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR void* nedmalloc_internals(size_t *granularity, size_t *magic) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR int nedmalloc_trim(size_t pad) THROWSPEC; NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR int nedmalloc_trim(size_t pad) THROWSPEC;
NEDMALLOCEXTSPEC void nedmalloc_stats(void) THROWSPEC; NEDMALLOCEXTSPEC void nedmalloc_stats(void) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR size_t nedmalloc_footprint(void) THROWSPEC; NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR size_t nedmalloc_footprint(void) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void **nedindependent_calloc(size_t elemsno, size_t elemsize, void **chunks) THROWSPEC; NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void **nedindependent_calloc(size_t elemsno, size_t elemsize, void **chunks) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void **nedindependent_comalloc(size_t elems, size_t *sizes, void **chunks) THROWSPEC; NEDMALLOCEXTSPEC NEDMALLOCNOALIASATTR NEDMALLOCPTRATTR void **nedindependent_comalloc(size_t elems, size_t *sizes, void **chunks) THROWSPEC;
/* Destroys the system memory pool used by the functions above. /* Destroys the system memory pool used by the functions above.
Useful for when you have nedmalloc in a DLL you're about to unload. Useful for when you have nedmalloc in a DLL you're about to unload.
If you call ANY nedmalloc functions after calling this you will If you call ANY nedmalloc functions after calling this you will
get a fatal exception! get a fatal exception!
*/ */
NEDMALLOCEXTSPEC void neddestroysyspool() THROWSPEC; NEDMALLOCEXTSPEC void neddestroysyspool() THROWSPEC;
/* These are the pool functions */ /* These are the pool functions */
struct nedpool_t; struct nedpool_t;
typedef struct nedpool_t nedpool; typedef struct nedpool_t nedpool;
/* Creates a memory pool for use with the nedp* functions below. /* Creates a memory pool for use with the nedp* functions below.
Capacity is how much to allocate immediately (if you know you'll be allocating a lot Capacity is how much to allocate immediately (if you know you'll be allocating a lot
of memory very soon) which you can leave at zero. Threads specifies how many threads of memory very soon) which you can leave at zero. Threads specifies how many threads
will *normally* be accessing the pool concurrently. Setting this to zero means it will *normally* be accessing the pool concurrently. Setting this to zero means it
extends on demand, but be careful of this as it can rapidly consume system resources extends on demand, but be careful of this as it can rapidly consume system resources
where bursts of concurrent threads use a pool at once. where bursts of concurrent threads use a pool at once.
*/ */
NEDMALLOCEXTSPEC NEDMALLOCPTRATTR nedpool *nedcreatepool(size_t capacity, int threads) THROWSPEC; NEDMALLOCEXTSPEC NEDMALLOCPTRATTR nedpool *nedcreatepool(size_t capacity, int threads) THROWSPEC;
/* Destroys a memory pool previously created by nedcreatepool(). /* Destroys a memory pool previously created by nedcreatepool().
*/ */
NEDMALLOCEXTSPEC void neddestroypool(nedpool *p) THROWSPEC; NEDMALLOCEXTSPEC void neddestroypool(nedpool *p) THROWSPEC;
/* Returns a zero terminated snapshot of threadpools existing at the time of call. Call /* Returns a zero terminated snapshot of threadpools existing at the time of call. Call
nedfree() on the returned list when you are done. Returns zero if there is only the nedfree() on the returned list when you are done. Returns zero if there is only the
system pool in existence. system pool in existence.
*/ */
NEDMALLOCEXTSPEC nedpool **nedpoollist() THROWSPEC; NEDMALLOCEXTSPEC nedpool **nedpoollist() THROWSPEC;
/* Sets a value to be associated with a pool. You can retrieve this value by passing /* Sets a value to be associated with a pool. You can retrieve this value by passing
any memory block allocated from that pool. any memory block allocated from that pool.
*/ */
NEDMALLOCEXTSPEC void nedpsetvalue(nedpool *p, void *v) THROWSPEC; NEDMALLOCEXTSPEC void nedpsetvalue(nedpool *p, void *v) THROWSPEC;
/* Gets a previously set value using nedpsetvalue() or zero if memory is unknown. /* Gets a previously set value using nedpsetvalue() or zero if memory is unknown.
Optionally can also retrieve pool. You can detect an unknown block by the return Optionally can also retrieve pool. You can detect an unknown block by the return
being zero and *p being unmodifed. being zero and *p being unmodifed.
*/ */
NEDMALLOCEXTSPEC void *nedgetvalue(nedpool **p, void *mem) THROWSPEC; NEDMALLOCEXTSPEC void *nedgetvalue(nedpool **p, void *mem) THROWSPEC;
/* Trims the thread cache for the calling thread, returning any existing cache /* Trims the thread cache for the calling thread, returning any existing cache
data to the central pool. Remember to ALWAYS call with zero if you used the data to the central pool. Remember to ALWAYS call with zero if you used the
system pool. Setting disable to non-zero replicates neddisablethreadcache(). system pool. Setting disable to non-zero replicates neddisablethreadcache().
*/ */
NEDMALLOCEXTSPEC void nedtrimthreadcache(nedpool *p, int disable) THROWSPEC; NEDMALLOCEXTSPEC void nedtrimthreadcache(nedpool *p, int disable) THROWSPEC;
/* Disables the thread cache for the calling thread, returning any existing cache /* Disables the thread cache for the calling thread, returning any existing cache
data to the central pool. Remember to ALWAYS call with zero if you used the data to the central pool. Remember to ALWAYS call with zero if you used the
system pool. system pool.
*/ */
NEDMALLOCEXTSPEC void neddisablethreadcache(nedpool *p) THROWSPEC; NEDMALLOCEXTSPEC void neddisablethreadcache(nedpool *p) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCPTRATTR void * nedpmalloc(nedpool *p, size_t size) THROWSPEC; NEDMALLOCEXTSPEC NEDMALLOCPTRATTR void * nedpmalloc(nedpool *p, size_t size) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCPTRATTR void * nedpcalloc(nedpool *p, size_t no, size_t size) THROWSPEC; NEDMALLOCEXTSPEC NEDMALLOCPTRATTR void * nedpcalloc(nedpool *p, size_t no, size_t size) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCPTRATTR void * nedprealloc(nedpool *p, void *mem, size_t size) THROWSPEC; NEDMALLOCEXTSPEC NEDMALLOCPTRATTR void * nedprealloc(nedpool *p, void *mem, size_t size) THROWSPEC;
NEDMALLOCEXTSPEC void nedpfree(nedpool *p, void *mem) THROWSPEC; NEDMALLOCEXTSPEC void nedpfree(nedpool *p, void *mem) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCPTRATTR void * nedpmemalign(nedpool *p, size_t alignment, size_t bytes) THROWSPEC; NEDMALLOCEXTSPEC NEDMALLOCPTRATTR void * nedpmemalign(nedpool *p, size_t alignment, size_t bytes) THROWSPEC;
NEDMALLOCEXTSPEC struct nedmallinfo nedpmallinfo(nedpool *p) THROWSPEC; NEDMALLOCEXTSPEC struct nedmallinfo nedpmallinfo(nedpool *p) THROWSPEC;
NEDMALLOCEXTSPEC int nedpmallopt(nedpool *p, int parno, int value) THROWSPEC; NEDMALLOCEXTSPEC int nedpmallopt(nedpool *p, int parno, int value) THROWSPEC;
NEDMALLOCEXTSPEC int nedpmalloc_trim(nedpool *p, size_t pad) THROWSPEC; NEDMALLOCEXTSPEC int nedpmalloc_trim(nedpool *p, size_t pad) THROWSPEC;
NEDMALLOCEXTSPEC void nedpmalloc_stats(nedpool *p) THROWSPEC; NEDMALLOCEXTSPEC void nedpmalloc_stats(nedpool *p) THROWSPEC;
NEDMALLOCEXTSPEC size_t nedpmalloc_footprint(nedpool *p) THROWSPEC; NEDMALLOCEXTSPEC size_t nedpmalloc_footprint(nedpool *p) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCPTRATTR void **nedpindependent_calloc(nedpool *p, size_t elemsno, size_t elemsize, void **chunks) THROWSPEC; NEDMALLOCEXTSPEC NEDMALLOCPTRATTR void **nedpindependent_calloc(nedpool *p, size_t elemsno, size_t elemsize, void **chunks) THROWSPEC;
NEDMALLOCEXTSPEC NEDMALLOCPTRATTR void **nedpindependent_comalloc(nedpool *p, size_t elems, size_t *sizes, void **chunks) THROWSPEC; NEDMALLOCEXTSPEC NEDMALLOCPTRATTR void **nedpindependent_comalloc(nedpool *p, size_t elems, size_t *sizes, void **chunks) THROWSPEC;
#if defined(__cplusplus) #if defined(__cplusplus)
} }
#endif #endif
#endif #endif
#endif #endif

38
drivers/openssl/register_openssl.cpp
View file

@ -1,19 +1,19 @@
#include "register_openssl.h" #include "register_openssl.h"
#include "stream_peer_openssl.h" #include "stream_peer_openssl.h"
#ifdef OPENSSL_ENABLED #ifdef OPENSSL_ENABLED
void register_openssl() { void register_openssl() {
ObjectTypeDB::register_type<StreamPeerOpenSSL>(); ObjectTypeDB::register_type<StreamPeerOpenSSL>();
StreamPeerOpenSSL::initialize_ssl(); StreamPeerOpenSSL::initialize_ssl();
} }
void unregister_openssl() { void unregister_openssl() {
StreamPeerOpenSSL::finalize_ssl(); StreamPeerOpenSSL::finalize_ssl();
} }
#endif #endif

22
drivers/openssl/register_openssl.h
View file

@ -1,11 +1,11 @@
#ifndef REGISTER_OPENSSL_H #ifndef REGISTER_OPENSSL_H
#define REGISTER_OPENSSL_H #define REGISTER_OPENSSL_H
#ifdef OPENSSL_ENABLED #ifdef OPENSSL_ENABLED
void register_openssl(); void register_openssl();
void unregister_openssl(); void unregister_openssl();
#endif #endif
#endif // REGISTER_OPENSSL_H #endif // REGISTER_OPENSSL_H

20468
drivers/rtaudio/RtAudio.cpp
View file

File diff suppressed because it is too large Load diff

104
drivers/speex/config.h
View file

@ -1,52 +1,52 @@
/* /*
Copyright (C) 2003 Commonwealth Scientific and Industrial Research Copyright (C) 2003 Commonwealth Scientific and Industrial Research
Organisation (CSIRO) Australia Organisation (CSIRO) Australia
Redistribution and use in source and binary forms, with or without Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions modification, are permitted provided that the following conditions
are met: are met:
- Redistributions of source code must retain the above copyright - Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer. notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright - Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution. documentation and/or other materials provided with the distribution.
- Neither the name of CSIRO Australia nor the names of its - Neither the name of CSIRO Australia nor the names of its
contributors may be used to endorse or promote products derived from contributors may be used to endorse or promote products derived from
this software without specific prior written permission. this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef CONFIG_H #ifndef CONFIG_H
#define CONFIG_H #define CONFIG_H
/* An inline macro is required for use of the inline keyword as not all C compilers support */ /* An inline macro is required for use of the inline keyword as not all C compilers support */
/* inline. It is officially C99 and C++ only */ /* inline. It is officially C99 and C++ only */
/* Use only fixed point arithmetic */ /* Use only fixed point arithmetic */
//#ifdef _MSC_VER //#ifdef _MSC_VER
//#define inline _inline //#define inline _inline
//#endif //#endif
#define FIXED_POINT 1 #define FIXED_POINT 1
#ifdef _MSC_VER #ifdef _MSC_VER
#define inline __inline #define inline __inline
#endif #endif
#endif /* ! CONFIG_H */ #endif /* ! CONFIG_H */

128
drivers/speex/lsp.h
View file

@ -1,64 +1,64 @@
/*---------------------------------------------------------------------------*\ /*---------------------------------------------------------------------------*\
Original Copyright Original Copyright
FILE........: AK2LSPD.H FILE........: AK2LSPD.H
TYPE........: Turbo C header file TYPE........: Turbo C header file
COMPANY.....: Voicetronix COMPANY.....: Voicetronix
AUTHOR......: James Whitehall AUTHOR......: James Whitehall
DATE CREATED: 21/11/95 DATE CREATED: 21/11/95
Modified by Jean-Marc Valin Modified by Jean-Marc Valin
This file contains functions for converting Linear Prediction This file contains functions for converting Linear Prediction
Coefficients (LPC) to Line Spectral Pair (LSP) and back. Note that the Coefficients (LPC) to Line Spectral Pair (LSP) and back. Note that the
LSP coefficients are not in radians format but in the x domain of the LSP coefficients are not in radians format but in the x domain of the
unit circle. unit circle.
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
/** /**
@file lsp.h @file lsp.h
@brief Line Spectral Pair (LSP) functions. @brief Line Spectral Pair (LSP) functions.
*/ */
/* Speex License: /* Speex License:
Redistribution and use in source and binary forms, with or without Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions modification, are permitted provided that the following conditions
are met: are met:
- Redistributions of source code must retain the above copyright - Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer. notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright - Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution. documentation and/or other materials provided with the distribution.
- Neither the name of the Xiph.org Foundation nor the names of its - Neither the name of the Xiph.org Foundation nor the names of its
contributors may be used to endorse or promote products derived from contributors may be used to endorse or promote products derived from
this software without specific prior written permission. this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#ifndef __AK2LSPD__ #ifndef __AK2LSPD__
#define __AK2LSPD__ #define __AK2LSPD__
#include "arch.h" #include "arch.h"
int lpc_to_lsp (spx_coef_t *a, int lpcrdr, spx_lsp_t *freq, int nb, spx_word16_t delta, char *stack); int lpc_to_lsp (spx_coef_t *a, int lpcrdr, spx_lsp_t *freq, int nb, spx_word16_t delta, char *stack);
void lsp_to_lpc(spx_lsp_t *freq, spx_coef_t *ak, int lpcrdr, char *stack); void lsp_to_lpc(spx_lsp_t *freq, spx_coef_t *ak, int lpcrdr, char *stack);
/*Added by JMV*/ /*Added by JMV*/
void lsp_enforce_margin(spx_lsp_t *lsp, int len, spx_word16_t margin); void lsp_enforce_margin(spx_lsp_t *lsp, int len, spx_word16_t margin);
void lsp_interpolate(spx_lsp_t *old_lsp, spx_lsp_t *new_lsp, spx_lsp_t *interp_lsp, int len, int subframe, int nb_subframes); void lsp_interpolate(spx_lsp_t *old_lsp, spx_lsp_t *new_lsp, spx_lsp_t *interp_lsp, int len, int subframe, int nb_subframes);
#endif /* __AK2LSPD__ */ #endif /* __AK2LSPD__ */

128
drivers/speex/speex_bind.cpp
View file

@ -1,64 +1,64 @@
#include "memory.h" #include "memory.h"
#include "speex_bind.h" #include "speex_bind.h"
#include #include
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
void *speex_alloc (int size) { void *speex_alloc (int size) {
uint8_t * mem = (uint8_t*)memalloc(size); uint8_t * mem = (uint8_t*)memalloc(size);
for(int i=0;i<size;i++) for(int i=0;i<size;i++)
mem[i]=0; mem[i]=0;
return mem; return mem;
} }
void *speex_alloc_scratch (int size) { void *speex_alloc_scratch (int size) {
return memalloc(size); return memalloc(size);
} }
void *speex_realloc (void *ptr, int size) { void *speex_realloc (void *ptr, int size) {
return memrealloc(ptr,size); return memrealloc(ptr,size);
} }
void speex_free (void *ptr) { void speex_free (void *ptr) {
memfree(ptr); memfree(ptr);
} }
void speex_free_scratch (void *ptr) { void speex_free_scratch (void *ptr) {
memfree(ptr); memfree(ptr);
} }
void _speex_fatal(const char *str, const char *file, int line) { void _speex_fatal(const char *str, const char *file, int line) {
_err_print_error("SPEEX ERROR",p_file,p_line,str); _err_print_error("SPEEX ERROR",p_file,p_line,str);
} }
void speex_warning(const char *str) { void speex_warning(const char *str) {
_err_print_error("SPEEX WARNING","",0,str); _err_print_error("SPEEX WARNING","",0,str);
} }
void speex_warning_int(const char *str, int val) { void speex_warning_int(const char *str, int val) {
_err_print_error("SPEEX WARNING INT","Value",val,str); _err_print_error("SPEEX WARNING INT","Value",val,str);
} }
void speex_notify(const char *str) { void speex_notify(const char *str) {
print_line(str); print_line(str);
} }
void _speex_putc(int ch, void *file) { void _speex_putc(int ch, void *file) {
// will not putc, no. // will not putc, no.
} }
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif

96
drivers/speex/speex_bind.h
View file

@ -1,48 +1,48 @@
#ifndef SPEEX_BIND_H #ifndef SPEEX_BIND_H
#define SPEEX_BIND_H #define SPEEX_BIND_H
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* /*
#define OVERRIDE_SPEEX_ALLOC #define OVERRIDE_SPEEX_ALLOC
#define OVERRIDE_SPEEX_ALLOC_SCRATCH #define OVERRIDE_SPEEX_ALLOC_SCRATCH
#define OVERRIDE_SPEEX_REALLOC #define OVERRIDE_SPEEX_REALLOC
#define OVERRIDE_SPEEX_FREE #define OVERRIDE_SPEEX_FREE
#define OVERRIDE_SPEEX_FREE_SCRATCH #define OVERRIDE_SPEEX_FREE_SCRATCH
#define OVERRIDE_SPEEX_FATAL #define OVERRIDE_SPEEX_FATAL
#define OVERRIDE_SPEEX_WARNING #define OVERRIDE_SPEEX_WARNING
#define OVERRIDE_SPEEX_WARNING_INT #define OVERRIDE_SPEEX_WARNING_INT
#define OVERRIDE_SPEEX_NOTIFY #define OVERRIDE_SPEEX_NOTIFY
#define OVERRIDE_SPEEX_PUTC #define OVERRIDE_SPEEX_PUTC
void *speex_alloc (int size); void *speex_alloc (int size);
void *speex_alloc_scratch (int size); void *speex_alloc_scratch (int size);
void *speex_realloc (void *ptr, int size); void *speex_realloc (void *ptr, int size);
void speex_free (void *ptr); void speex_free (void *ptr);
void speex_free_scratch (void *ptr); void speex_free_scratch (void *ptr);
void _speex_fatal(const char *str, const char *file, int line); void _speex_fatal(const char *str, const char *file, int line);
void speex_warning(const char *str); void speex_warning(const char *str);
void speex_warning_int(const char *str, int val); void speex_warning_int(const char *str, int val);
void speex_notify(const char *str); void speex_notify(const char *str);
void _speex_putc(int ch, void *file); void _speex_putc(int ch, void *file);
*/ */
#define RELEASE #define RELEASE
#define SPEEX_PI 3.14159265358979323846 #define SPEEX_PI 3.14159265358979323846
#ifdef _MSC_VER #ifdef _MSC_VER
#define SPEEX_INLINE __inline #define SPEEX_INLINE __inline
#else #else
#define SPEEX_INLINE inline #define SPEEX_INLINE inline
#endif #endif
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif // SPEEX_BIND_H #endif // SPEEX_BIND_H

176
platform/flash/os_flash.h
View file

@ -1,88 +1,88 @@
#ifndef OS_FLASH_H #ifndef OS_FLASH_H
#define OS_FLASH_H #define OS_FLASH_H
#include "os/input.h" #include "os/input.h"
#include "drivers/unix/os_unix.h" #include "drivers/unix/os_unix.h"
#include "os/input.h" #include "os/input.h"
#include "servers/visual_server.h" #include "servers/visual_server.h"
#include "servers/visual/rasterizer.h" #include "servers/visual/rasterizer.h"
#include "servers/physics/physics_server_sw.h" #include "servers/physics/physics_server_sw.h"
#include "servers/spatial_sound/spatial_sound_server_sw.h" #include "servers/spatial_sound/spatial_sound_server_sw.h"
#include "servers/spatial_sound_2d/spatial_sound_2d_server_sw.h" #include "servers/spatial_sound_2d/spatial_sound_2d_server_sw.h"
#include "servers/audio/audio_server_sw.h" #include "servers/audio/audio_server_sw.h"
#include "servers/physics_2d/physics_2d_server_sw.h" #include "servers/physics_2d/physics_2d_server_sw.h"
#include "main/input_default.h" #include "main/input_default.h"
class OSFlash : public OS_Unix { class OSFlash : public OS_Unix {
VideoMode default_videomode; VideoMode default_videomode;
MainLoop * main_loop; MainLoop * main_loop;
InputDefault *input; InputDefault *input;
Rasterizer *rasterizer; Rasterizer *rasterizer;
VisualServer *visual_server; VisualServer *visual_server;
AudioDriverSW* audio_driver; AudioDriverSW* audio_driver;
AudioServerSW *audio_server; AudioServerSW *audio_server;
SampleManagerMallocSW *sample_manager; SampleManagerMallocSW *sample_manager;
SpatialSoundServerSW *spatial_sound_server; SpatialSoundServerSW *spatial_sound_server;
SpatialSound2DServerSW *spatial_sound_2d_server; SpatialSound2DServerSW *spatial_sound_2d_server;
PhysicsServer *physics_server; PhysicsServer *physics_server;
Physics2DServer *physics_2d_server; Physics2DServer *physics_2d_server;
public: public:
virtual int get_video_driver_count() const; virtual int get_video_driver_count() const;
virtual const char * get_video_driver_name(int p_driver) const; virtual const char * get_video_driver_name(int p_driver) const;
virtual VideoMode get_default_video_mode() const; virtual VideoMode get_default_video_mode() const;
virtual int get_audio_driver_count() const; virtual int get_audio_driver_count() const;
virtual const char * get_audio_driver_name(int p_driver) const; virtual const char * get_audio_driver_name(int p_driver) const;
virtual void initialize_core(); virtual void initialize_core();
virtual void initialize(const VideoMode& p_desired,int p_video_driver,int p_audio_driver); virtual void initialize(const VideoMode& p_desired,int p_video_driver,int p_audio_driver);
virtual void set_main_loop( MainLoop * p_main_loop ); virtual void set_main_loop( MainLoop * p_main_loop );
virtual void delete_main_loop(); virtual void delete_main_loop();
virtual void finalize(); virtual void finalize();
typedef int64_t ProcessID; typedef int64_t ProcessID;
static OS* get_singleton(); static OS* get_singleton();
virtual void set_mouse_show(bool p_show); virtual void set_mouse_show(bool p_show);
virtual void set_mouse_grab(bool p_grab); virtual void set_mouse_grab(bool p_grab);
virtual bool is_mouse_grab_enabled() const; virtual bool is_mouse_grab_enabled() const;
virtual Point2 get_mouse_pos() const; virtual Point2 get_mouse_pos() const;
virtual int get_mouse_button_state() const; virtual int get_mouse_button_state() const;
virtual void set_window_title(const String& p_title); virtual void set_window_title(const String& p_title);
//virtual void set_clipboard(const String& p_text); //virtual void set_clipboard(const String& p_text);
//virtual String get_clipboard() const; //virtual String get_clipboard() const;
virtual bool has_virtual_keyboard() const; virtual bool has_virtual_keyboard() const;
virtual void show_virtual_keyboard(const String& p_existing_text,const Rect2& p_screen_rect); virtual void show_virtual_keyboard(const String& p_existing_text,const Rect2& p_screen_rect);
virtual void hide_virtual_keyboard(); virtual void hide_virtual_keyboard();
virtual void set_video_mode(const VideoMode& p_video_mode,int p_screen=0); virtual void set_video_mode(const VideoMode& p_video_mode,int p_screen=0);
virtual VideoMode get_video_mode(int p_screen=0) const; virtual VideoMode get_video_mode(int p_screen=0) const;
virtual void get_fullscreen_mode_list(List<VideoMode> *p_list,int p_screen=0) const; virtual void get_fullscreen_mode_list(List<VideoMode> *p_list,int p_screen=0) const;
virtual String get_name(); virtual String get_name();
virtual MainLoop *get_main_loop() const; virtual MainLoop *get_main_loop() const;
virtual bool can_draw() const; virtual bool can_draw() const;
virtual void set_cursor_shape(CursorShape p_shape); virtual void set_cursor_shape(CursorShape p_shape);
virtual bool has_touchscreen_ui_hint() const; virtual bool has_touchscreen_ui_hint() const;
virtual void yield(); virtual void yield();
virtual Error shell_open(String p_uri); virtual Error shell_open(String p_uri);
bool iterate(); bool iterate();
}; };
#endif #endif

770
platform/winrt/app.cpp
View file

@ -1,385 +1,385 @@
// //
// This file demonstrates how to initialize EGL in a Windows Store app, using ICoreWindow. // This file demonstrates how to initialize EGL in a Windows Store app, using ICoreWindow.
// //
#include "app.h" #include "app.h"
#include "main/main.h" #include "main/main.h"
#include "core/os/dir_access.h" #include "core/os/dir_access.h"
#include "core/os/file_access.h" #include "core/os/file_access.h"
using namespace Windows::ApplicationModel::Core; using namespace Windows::ApplicationModel::Core;
using namespace Windows::ApplicationModel::Activation; using namespace Windows::ApplicationModel::Activation;
using namespace Windows::UI::Core; using namespace Windows::UI::Core;
using namespace Windows::UI::Input; using namespace Windows::UI::Input;
using namespace Windows::Foundation; using namespace Windows::Foundation;
using namespace Windows::Graphics::Display; using namespace Windows::Graphics::Display;
using namespace Microsoft::WRL; using namespace Microsoft::WRL;
using namespace Platform; using namespace Platform;
using namespace $ext_safeprojectname$; using namespace $ext_safeprojectname$;
// Helper to convert a length in device-independent pixels (DIPs) to a length in physical pixels. // Helper to convert a length in device-independent pixels (DIPs) to a length in physical pixels.
inline float ConvertDipsToPixels(float dips, float dpi) inline float ConvertDipsToPixels(float dips, float dpi)
{ {
static const float dipsPerInch = 96.0f; static const float dipsPerInch = 96.0f;
return floor(dips * dpi / dipsPerInch + 0.5f); // Round to nearest integer. return floor(dips * dpi / dipsPerInch + 0.5f); // Round to nearest integer.
} }
// Implementation of the IFrameworkViewSource interface, necessary to run our app. // Implementation of the IFrameworkViewSource interface, necessary to run our app.
ref class HelloTriangleApplicationSource sealed : Windows::ApplicationModel::Core::IFrameworkViewSource ref class HelloTriangleApplicationSource sealed : Windows::ApplicationModel::Core::IFrameworkViewSource
{ {
public: public:
virtual Windows::ApplicationModel::Core::IFrameworkView^ CreateView() virtual Windows::ApplicationModel::Core::IFrameworkView^ CreateView()
{ {
return ref new App(); return ref new App();
} }
}; };
// The main function creates an IFrameworkViewSource for our app, and runs the app. // The main function creates an IFrameworkViewSource for our app, and runs the app.
[Platform::MTAThread] [Platform::MTAThread]
int main(Platform::Array<Platform::String^>^) int main(Platform::Array<Platform::String^>^)
{ {
auto helloTriangleApplicationSource = ref new HelloTriangleApplicationSource(); auto helloTriangleApplicationSource = ref new HelloTriangleApplicationSource();
CoreApplication::Run(helloTriangleApplicationSource); CoreApplication::Run(helloTriangleApplicationSource);
return 0; return 0;
} }
App::App() : App::App() :
mWindowClosed(false), mWindowClosed(false),
mWindowVisible(true), mWindowVisible(true),
mWindowWidth(0), mWindowWidth(0),
mWindowHeight(0), mWindowHeight(0),
mEglDisplay(EGL_NO_DISPLAY), mEglDisplay(EGL_NO_DISPLAY),
mEglContext(EGL_NO_CONTEXT), mEglContext(EGL_NO_CONTEXT),
mEglSurface(EGL_NO_SURFACE) mEglSurface(EGL_NO_SURFACE)
{ {
} }
// The first method called when the IFrameworkView is being created. // The first method called when the IFrameworkView is being created.
void App::Initialize(CoreApplicationView^ applicationView) void App::Initialize(CoreApplicationView^ applicationView)
{ {
// Register event handlers for app lifecycle. This example includes Activated, so that we // Register event handlers for app lifecycle. This example includes Activated, so that we
// can make the CoreWindow active and start rendering on the window. // can make the CoreWindow active and start rendering on the window.
applicationView->Activated += applicationView->Activated +=
ref new TypedEventHandler<CoreApplicationView^, IActivatedEventArgs^>(this, &App::OnActivated); ref new TypedEventHandler<CoreApplicationView^, IActivatedEventArgs^>(this, &App::OnActivated);
// Logic for other event handlers could go here. // Logic for other event handlers could go here.
// Information about the Suspending and Resuming event handlers can be found here: // Information about the Suspending and Resuming event handlers can be found here:
// http://msdn.microsoft.com/en-us/library/windows/apps/xaml/hh994930.aspx // http://msdn.microsoft.com/en-us/library/windows/apps/xaml/hh994930.aspx
os = new OSWinrt; os = new OSWinrt;
} }
// Called when the CoreWindow object is created (or re-created). // Called when the CoreWindow object is created (or re-created).
void App::SetWindow(CoreWindow^ p_window) void App::SetWindow(CoreWindow^ p_window)
{ {
window = p_window; window = p_window;
window->VisibilityChanged += window->VisibilityChanged +=
ref new TypedEventHandler<CoreWindow^, VisibilityChangedEventArgs^>(this, &App::OnVisibilityChanged); ref new TypedEventHandler<CoreWindow^, VisibilityChangedEventArgs^>(this, &App::OnVisibilityChanged);
window->Closed += window->Closed +=
ref new TypedEventHandler<CoreWindow^, CoreWindowEventArgs^>(this, &App::OnWindowClosed); ref new TypedEventHandler<CoreWindow^, CoreWindowEventArgs^>(this, &App::OnWindowClosed);
window->SizeChanged += window->SizeChanged +=
ref new TypedEventHandler<CoreWindow^, WindowSizeChangedEventArgs^>(this, &App::OnWindowSizeChanged); ref new TypedEventHandler<CoreWindow^, WindowSizeChangedEventArgs^>(this, &App::OnWindowSizeChanged);
#if !(WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP) #if !(WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP)
// Disable all pointer visual feedback for better performance when touching. // Disable all pointer visual feedback for better performance when touching.
// This is not supported on Windows Phone applications. // This is not supported on Windows Phone applications.
auto pointerVisualizationSettings = PointerVisualizationSettings::GetForCurrentView(); auto pointerVisualizationSettings = PointerVisualizationSettings::GetForCurrentView();
pointerVisualizationSettings->IsContactFeedbackEnabled = false; pointerVisualizationSettings->IsContactFeedbackEnabled = false;
pointerVisualizationSettings->IsBarrelButtonFeedbackEnabled = false; pointerVisualizationSettings->IsBarrelButtonFeedbackEnabled = false;
#endif #endif
window->PointerPressed += window->PointerPressed +=
ref new TypedEventHandler<CoreWindow^, PointerEventArgs^>(this, &App::OnPointerPressed); ref new TypedEventHandler<CoreWindow^, PointerEventArgs^>(this, &App::OnPointerPressed);
window->PointerMoved += window->PointerMoved +=
ref new TypedEventHandler<CoreWindow^, PointerEventArgs^>(this, &App::OnPointerMoved); ref new TypedEventHandler<CoreWindow^, PointerEventArgs^>(this, &App::OnPointerMoved);
window->PointerReleased += window->PointerReleased +=
ref new TypedEventHandler<CoreWindow^, PointerEventArgs^>(this, &App::OnPointerReleased); ref new TypedEventHandler<CoreWindow^, PointerEventArgs^>(this, &App::OnPointerReleased);
//window->PointerWheelChanged += //window->PointerWheelChanged +=
// ref new TypedEventHandler<CoreWindow^, PointerEventArgs^>(this, &App::OnPointerWheelChanged); // ref new TypedEventHandler<CoreWindow^, PointerEventArgs^>(this, &App::OnPointerWheelChanged);
char* args[] = {"-path", "game", NULL}; char* args[] = {"-path", "game", NULL};
Main::setup("winrt", 2, args, false); Main::setup("winrt", 2, args, false);
// The CoreWindow has been created, so EGL can be initialized. // The CoreWindow has been created, so EGL can be initialized.
ContextEGL* context = memnew(ContextEGL(window)); ContextEGL* context = memnew(ContextEGL(window));
os->set_gl_context(context); os->set_gl_context(context);
UpdateWindowSize(Size(window->Bounds.Width, window->Bounds.Height)); UpdateWindowSize(Size(window->Bounds.Width, window->Bounds.Height));
Main::setup2(); Main::setup2();
} }
static int _get_button(Windows::UI::Input::PointerPoint ^pt) { static int _get_button(Windows::UI::Input::PointerPoint ^pt) {
using namespace Windows::UI::Input; using namespace Windows::UI::Input;
#if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP #if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
return BUTTON_LEFT; return BUTTON_LEFT;
#else #else
switch (pt->Properties->PointerUpdateKind) switch (pt->Properties->PointerUpdateKind)
{ {
case PointerUpdateKind::LeftButtonPressed: case PointerUpdateKind::LeftButtonPressed:
case PointerUpdateKind::LeftButtonReleased: case PointerUpdateKind::LeftButtonReleased:
return BUTTON_LEFT; return BUTTON_LEFT;
case PointerUpdateKind::RightButtonPressed: case PointerUpdateKind::RightButtonPressed:
case PointerUpdateKind::RightButtonReleased: case PointerUpdateKind::RightButtonReleased:
return BUTTON_RIGHT; return BUTTON_RIGHT;
case PointerUpdateKind::MiddleButtonPressed: case PointerUpdateKind::MiddleButtonPressed:
case PointerUpdateKind::MiddleButtonReleased: case PointerUpdateKind::MiddleButtonReleased:
return BUTTON_MIDDLE; return BUTTON_MIDDLE;
case PointerUpdateKind::XButton1Pressed: case PointerUpdateKind::XButton1Pressed:
case PointerUpdateKind::XButton1Released: case PointerUpdateKind::XButton1Released:
return BUTTON_WHEEL_UP; return BUTTON_WHEEL_UP;
case PointerUpdateKind::XButton2Pressed: case PointerUpdateKind::XButton2Pressed:
case PointerUpdateKind::XButton2Released: case PointerUpdateKind::XButton2Released:
return BUTTON_WHEEL_DOWN; return BUTTON_WHEEL_DOWN;
default: default:
break; break;
} }
#endif #endif
return 0; return 0;
}; };
static bool _is_touch(Windows::UI::Input::PointerPoint ^pointerPoint) { static bool _is_touch(Windows::UI::Input::PointerPoint ^pointerPoint) {
#if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP #if WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP
return true; return true;
#else #else
using namespace Windows::Devices::Input; using namespace Windows::Devices::Input;
switch (pointerPoint->PointerDevice->PointerDeviceType) { switch (pointerPoint->PointerDevice->PointerDeviceType) {
case PointerDeviceType::Touch: case PointerDeviceType::Touch:
case PointerDeviceType::Pen: case PointerDeviceType::Pen:
return true; return true;
default: default:
return false; return false;
} }
#endif #endif
} }
static Windows::Foundation::Point _get_pixel_position(CoreWindow^ window, Windows::Foundation::Point rawPosition, OS* os) { static Windows::Foundation::Point _get_pixel_position(CoreWindow^ window, Windows::Foundation::Point rawPosition, OS* os) {
Windows::Foundation::Point outputPosition; Windows::Foundation::Point outputPosition;
// Compute coordinates normalized from 0..1. // Compute coordinates normalized from 0..1.
// If the coordinates need to be sized to the SDL window, // If the coordinates need to be sized to the SDL window,
// we'll do that after. // we'll do that after.
#if 1 || WINAPI_FAMILY != WINAPI_FAMILY_PHONE_APP #if 1 || WINAPI_FAMILY != WINAPI_FAMILY_PHONE_APP
outputPosition.X = rawPosition.X / window->Bounds.Width; outputPosition.X = rawPosition.X / window->Bounds.Width;
outputPosition.Y = rawPosition.Y / window->Bounds.Height; outputPosition.Y = rawPosition.Y / window->Bounds.Height;
#else #else
switch (DisplayProperties::CurrentOrientation) switch (DisplayProperties::CurrentOrientation)
{ {
case DisplayOrientations::Portrait: case DisplayOrientations::Portrait:
outputPosition.X = rawPosition.X / window->Bounds.Width; outputPosition.X = rawPosition.X / window->Bounds.Width;
outputPosition.Y = rawPosition.Y / window->Bounds.Height; outputPosition.Y = rawPosition.Y / window->Bounds.Height;
break; break;
case DisplayOrientations::PortraitFlipped: case DisplayOrientations::PortraitFlipped:
outputPosition.X = 1.0f - (rawPosition.X / window->Bounds.Width); outputPosition.X = 1.0f - (rawPosition.X / window->Bounds.Width);
outputPosition.Y = 1.0f - (rawPosition.Y / window->Bounds.Height); outputPosition.Y = 1.0f - (rawPosition.Y / window->Bounds.Height);
break; break;
case DisplayOrientations::Landscape: case DisplayOrientations::Landscape:
outputPosition.X = rawPosition.Y / window->Bounds.Height; outputPosition.X = rawPosition.Y / window->Bounds.Height;
outputPosition.Y = 1.0f - (rawPosition.X / window->Bounds.Width); outputPosition.Y = 1.0f - (rawPosition.X / window->Bounds.Width);
break; break;
case DisplayOrientations::LandscapeFlipped: case DisplayOrientations::LandscapeFlipped:
outputPosition.X = 1.0f - (rawPosition.Y / window->Bounds.Height); outputPosition.X = 1.0f - (rawPosition.Y / window->Bounds.Height);
outputPosition.Y = rawPosition.X / window->Bounds.Width; outputPosition.Y = rawPosition.X / window->Bounds.Width;
break; break;
default: default:
break; break;
} }
#endif #endif
OS::VideoMode vm = os->get_video_mode(); OS::VideoMode vm = os->get_video_mode();
outputPosition.X *= vm.width; outputPosition.X *= vm.width;
outputPosition.Y *= vm.height; outputPosition.Y *= vm.height;
return outputPosition; return outputPosition;
}; };
static int _get_finger(uint32_t p_touch_id) { static int _get_finger(uint32_t p_touch_id) {
return p_touch_id % 31; // for now return p_touch_id % 31; // for now
}; };
void App::pointer_event(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args, bool p_pressed) { void App::pointer_event(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args, bool p_pressed) {
Windows::UI::Input::PointerPoint ^point = args->CurrentPoint; Windows::UI::Input::PointerPoint ^point = args->CurrentPoint;
Windows::Foundation::Point pos = _get_pixel_position(window, point->Position, os); Windows::Foundation::Point pos = _get_pixel_position(window, point->Position, os);
int but = _get_button(point); int but = _get_button(point);
if (_is_touch(point)) { if (_is_touch(point)) {
InputEvent event; InputEvent event;
event.type = InputEvent::SCREEN_TOUCH; event.type = InputEvent::SCREEN_TOUCH;
event.device = 0; event.device = 0;
event.screen_touch.pressed = p_pressed; event.screen_touch.pressed = p_pressed;
event.screen_touch.x = pos.X; event.screen_touch.x = pos.X;
event.screen_touch.y = pos.Y; event.screen_touch.y = pos.Y;
event.screen_touch.index = _get_finger(point->PointerId); event.screen_touch.index = _get_finger(point->PointerId);
last_touch_x[event.screen_touch.index] = pos.X; last_touch_x[event.screen_touch.index] = pos.X;
last_touch_y[event.screen_touch.index] = pos.Y; last_touch_y[event.screen_touch.index] = pos.Y;
os->input_event(event); os->input_event(event);
if (event.screen_touch.index != 0) if (event.screen_touch.index != 0)
return; return;
}; // fallthrought of sorts }; // fallthrought of sorts
InputEvent event; InputEvent event;
event.type = InputEvent::MOUSE_BUTTON; event.type = InputEvent::MOUSE_BUTTON;
event.device = 0; event.device = 0;
event.mouse_button.pressed = p_pressed; event.mouse_button.pressed = p_pressed;
event.mouse_button.button_index = but; event.mouse_button.button_index = but;
event.mouse_button.x = pos.X; event.mouse_button.x = pos.X;
event.mouse_button.y = pos.Y; event.mouse_button.y = pos.Y;
event.mouse_button.global_x = pos.X; event.mouse_button.global_x = pos.X;
event.mouse_button.global_y = pos.Y; event.mouse_button.global_y = pos.Y;
last_touch_x[31] = pos.X; last_touch_x[31] = pos.X;
last_touch_y[31] = pos.Y; last_touch_y[31] = pos.Y;
os->input_event(event); os->input_event(event);
}; };
void App::OnPointerPressed(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args) { void App::OnPointerPressed(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args) {
pointer_event(sender, args, true); pointer_event(sender, args, true);
}; };
void App::OnPointerReleased(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args) { void App::OnPointerReleased(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args) {
pointer_event(sender, args, false); pointer_event(sender, args, false);
}; };
void App::OnPointerMoved(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args) { void App::OnPointerMoved(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args) {
Windows::UI::Input::PointerPoint ^point = args->CurrentPoint; Windows::UI::Input::PointerPoint ^point = args->CurrentPoint;
Windows::Foundation::Point pos = _get_pixel_position(window, point->Position, os); Windows::Foundation::Point pos = _get_pixel_position(window, point->Position, os);
if (_is_touch(point)) { if (_is_touch(point)) {
InputEvent event; InputEvent event;
event.type = InputEvent::SCREEN_DRAG; event.type = InputEvent::SCREEN_DRAG;
event.device = 0; event.device = 0;
event.screen_drag.x = pos.X; event.screen_drag.x = pos.X;
event.screen_drag.y = pos.Y; event.screen_drag.y = pos.Y;
event.screen_drag.index = _get_finger(point->PointerId); event.screen_drag.index = _get_finger(point->PointerId);
event.screen_drag.relative_x = event.screen_drag.x - last_touch_x[event.screen_drag.index]; event.screen_drag.relative_x = event.screen_drag.x - last_touch_x[event.screen_drag.index];
event.screen_drag.relative_y = event.screen_drag.y - last_touch_y[event.screen_drag.index]; event.screen_drag.relative_y = event.screen_drag.y - last_touch_y[event.screen_drag.index];
os->input_event(event); os->input_event(event);
if (event.screen_drag.index != 0) if (event.screen_drag.index != 0)
return; return;
}; // fallthrought of sorts }; // fallthrought of sorts
InputEvent event; InputEvent event;
event.type = InputEvent::MOUSE_MOTION; event.type = InputEvent::MOUSE_MOTION;
event.device = 0; event.device = 0;
event.mouse_motion.x = pos.X; event.mouse_motion.x = pos.X;
event.mouse_motion.y = pos.Y; event.mouse_motion.y = pos.Y;
event.mouse_motion.global_x = pos.X; event.mouse_motion.global_x = pos.X;
event.mouse_motion.global_y = pos.Y; event.mouse_motion.global_y = pos.Y;
event.mouse_motion.relative_x = pos.X - last_touch_x[31]; event.mouse_motion.relative_x = pos.X - last_touch_x[31];
event.mouse_motion.relative_y = pos.Y - last_touch_y[31]; event.mouse_motion.relative_y = pos.Y - last_touch_y[31];
os->input_event(event); os->input_event(event);
}; };
// Initializes scene resources // Initializes scene resources
void App::Load(Platform::String^ entryPoint) void App::Load(Platform::String^ entryPoint)
{ {
//char* args[] = {"-test", "render", NULL}; //char* args[] = {"-test", "render", NULL};
//Main::setup("winrt", 2, args); //Main::setup("winrt", 2, args);
} }
// This method is called after the window becomes active. // This method is called after the window becomes active.
void App::Run() void App::Run()
{ {
if (Main::start()) if (Main::start())
os->run(); os->run();
} }
// Terminate events do not cause Uninitialize to be called. It will be called if your IFrameworkView // Terminate events do not cause Uninitialize to be called. It will be called if your IFrameworkView
// class is torn down while the app is in the foreground. // class is torn down while the app is in the foreground.
void App::Uninitialize() void App::Uninitialize()
{ {
Main::cleanup(); Main::cleanup();
delete os; delete os;
} }
// Application lifecycle event handler. // Application lifecycle event handler.
void App::OnActivated(CoreApplicationView^ applicationView, IActivatedEventArgs^ args) void App::OnActivated(CoreApplicationView^ applicationView, IActivatedEventArgs^ args)
{ {
// Run() won't start until the CoreWindow is activated. // Run() won't start until the CoreWindow is activated.
CoreWindow::GetForCurrentThread()->Activate(); CoreWindow::GetForCurrentThread()->Activate();
} }
// Window event handlers. // Window event handlers.
void App::OnVisibilityChanged(CoreWindow^ sender, VisibilityChangedEventArgs^ args) void App::OnVisibilityChanged(CoreWindow^ sender, VisibilityChangedEventArgs^ args)
{ {
mWindowVisible = args->Visible; mWindowVisible = args->Visible;
} }
void App::OnWindowClosed(CoreWindow^ sender, CoreWindowEventArgs^ args) void App::OnWindowClosed(CoreWindow^ sender, CoreWindowEventArgs^ args)
{ {
mWindowClosed = true; mWindowClosed = true;
} }
void App::OnWindowSizeChanged(CoreWindow^ sender, WindowSizeChangedEventArgs^ args) void App::OnWindowSizeChanged(CoreWindow^ sender, WindowSizeChangedEventArgs^ args)
{ {
#if (WINAPI_FAMILY == WINAPI_FAMILY_PC_APP) #if (WINAPI_FAMILY == WINAPI_FAMILY_PC_APP)
// On Windows 8.1, apps are resized when they are snapped alongside other apps, or when the device is rotated. // On Windows 8.1, apps are resized when they are snapped alongside other apps, or when the device is rotated.
// The default framebuffer will be automatically resized when either of these occur. // The default framebuffer will be automatically resized when either of these occur.
// In particular, on a 90 degree rotation, the default framebuffer's width and height will switch. // In particular, on a 90 degree rotation, the default framebuffer's width and height will switch.
UpdateWindowSize(args->Size); UpdateWindowSize(args->Size);
#else if (WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP) #else if (WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP)
// On Windows Phone 8.1, the window size changes when the device is rotated. // On Windows Phone 8.1, the window size changes when the device is rotated.
// The default framebuffer will not be automatically resized when this occurs. // The default framebuffer will not be automatically resized when this occurs.
// It is therefore up to the app to handle rotation-specific logic in its rendering code. // It is therefore up to the app to handle rotation-specific logic in its rendering code.
//os->screen_size_changed(); //os->screen_size_changed();
UpdateWindowSize(args->Size); UpdateWindowSize(args->Size);
#endif #endif
} }
void App::UpdateWindowSize(Size size) void App::UpdateWindowSize(Size size)
{ {
float dpi; float dpi;
#if (WINAPI_FAMILY == WINAPI_FAMILY_PC_APP) #if (WINAPI_FAMILY == WINAPI_FAMILY_PC_APP)
DisplayInformation^ currentDisplayInformation = DisplayInformation::GetForCurrentView(); DisplayInformation^ currentDisplayInformation = DisplayInformation::GetForCurrentView();
dpi = currentDisplayInformation->LogicalDpi; dpi = currentDisplayInformation->LogicalDpi;
#else if (WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP) #else if (WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP)
dpi = DisplayProperties::LogicalDpi; dpi = DisplayProperties::LogicalDpi;
#endif #endif
Size pixelSize(ConvertDipsToPixels(size.Width, dpi), ConvertDipsToPixels(size.Height, dpi)); Size pixelSize(ConvertDipsToPixels(size.Width, dpi), ConvertDipsToPixels(size.Height, dpi));
mWindowWidth = static_cast<GLsizei>(pixelSize.Width); mWindowWidth = static_cast<GLsizei>(pixelSize.Width);
mWindowHeight = static_cast<GLsizei>(pixelSize.Height); mWindowHeight = static_cast<GLsizei>(pixelSize.Height);
OS::VideoMode vm; OS::VideoMode vm;
vm.width = mWindowWidth; vm.width = mWindowWidth;
vm.height = mWindowHeight; vm.height = mWindowHeight;
vm.fullscreen = true; vm.fullscreen = true;
vm.resizable = false; vm.resizable = false;
os->set_video_mode(vm); os->set_video_mode(vm);
} }

122
platform/winrt/app.h
View file

@ -1,61 +1,61 @@
#pragma once #pragma once
#include <string> #include <string>
#include <wrl.h> #include <wrl.h>
#include "os_winrt.h" #include "os_winrt.h"
#include "GLES2/gl2.h" #include "GLES2/gl2.h"
namespace $ext_safeprojectname$ namespace $ext_safeprojectname$
{ {
ref class App sealed : public Windows::ApplicationModel::Core::IFrameworkView ref class App sealed : public Windows::ApplicationModel::Core::IFrameworkView
{ {
public: public:
App(); App();
// IFrameworkView Methods. // IFrameworkView Methods.
virtual void Initialize(Windows::ApplicationModel::Core::CoreApplicationView^ applicationView); virtual void Initialize(Windows::ApplicationModel::Core::CoreApplicationView^ applicationView);
virtual void SetWindow(Windows::UI::Core::CoreWindow^ window); virtual void SetWindow(Windows::UI::Core::CoreWindow^ window);
virtual void Load(Platform::String^ entryPoint); virtual void Load(Platform::String^ entryPoint);
virtual void Run(); virtual void Run();
virtual void Uninitialize(); virtual void Uninitialize();
private: private:
void RecreateRenderer(); void RecreateRenderer();
// Application lifecycle event handlers. // Application lifecycle event handlers.
void OnActivated(Windows::ApplicationModel::Core::CoreApplicationView^ applicationView, Windows::ApplicationModel::Activation::IActivatedEventArgs^ args); void OnActivated(Windows::ApplicationModel::Core::CoreApplicationView^ applicationView, Windows::ApplicationModel::Activation::IActivatedEventArgs^ args);
// Window event handlers. // Window event handlers.
void OnWindowSizeChanged(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::WindowSizeChangedEventArgs^ args); void OnWindowSizeChanged(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::WindowSizeChangedEventArgs^ args);
void OnVisibilityChanged(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::VisibilityChangedEventArgs^ args); void OnVisibilityChanged(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::VisibilityChangedEventArgs^ args);
void OnWindowClosed(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::CoreWindowEventArgs^ args); void OnWindowClosed(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::CoreWindowEventArgs^ args);
void pointer_event(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args, bool p_pressed); void pointer_event(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args, bool p_pressed);
void OnPointerPressed(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args); void OnPointerPressed(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args);
void OnPointerReleased(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args); void OnPointerReleased(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args);
void OnPointerMoved(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args); void OnPointerMoved(Windows::UI::Core::CoreWindow^ sender, Windows::UI::Core::PointerEventArgs^ args);
void UpdateWindowSize(Windows::Foundation::Size size); void UpdateWindowSize(Windows::Foundation::Size size);
void InitializeEGL(Windows::UI::Core::CoreWindow^ window); void InitializeEGL(Windows::UI::Core::CoreWindow^ window);
void CleanupEGL(); void CleanupEGL();
bool mWindowClosed; bool mWindowClosed;
bool mWindowVisible; bool mWindowVisible;
GLsizei mWindowWidth; GLsizei mWindowWidth;
GLsizei mWindowHeight; GLsizei mWindowHeight;
EGLDisplay mEglDisplay; EGLDisplay mEglDisplay;
EGLContext mEglContext; EGLContext mEglContext;
EGLSurface mEglSurface; EGLSurface mEglSurface;
CoreWindow^ window; CoreWindow^ window;
OSWinrt* os; OSWinrt* os;
int last_touch_x[32]; // 20 fingers, index 31 reserved for the mouse int last_touch_x[32]; // 20 fingers, index 31 reserved for the mouse
int last_touch_y[32]; int last_touch_y[32];
}; };
} }

312
platform/winrt/detect.py
View file

@ -1,156 +1,156 @@
import os import os
import sys import sys
import string import string
def is_active(): def is_active():
return True return True
def get_name(): def get_name():
return "WinRT" return "WinRT"
def can_build(): def can_build():
if (os.name=="nt"): if (os.name=="nt"):
#building natively on windows! #building natively on windows!
if (os.getenv("VSINSTALLDIR")): if (os.getenv("VSINSTALLDIR")):
return True return True
return False return False
def get_opts(): def get_opts():
return [] return []
def get_flags(): def get_flags():
return [] return []
def configure(env): def configure(env):
env.Append(CPPPATH=['#platform/winrt', '#platform/winrt/include']) env.Append(CPPPATH=['#platform/winrt', '#platform/winrt/include'])
arch = "" arch = ""
if os.getenv('PLATFORM') == "ARM": if os.getenv('PLATFORM') == "ARM":
# compiler commandline # compiler commandline
# debug: /Yu"pch.h" /MP /GS /analyze- /W3 /wd"4453" /wd"28204" /Zc:wchar_t /I"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\App2\App2.WindowsPhone\" /I"Generated Files\" /I"ARM\Debug\" /I"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\App2\App2.Shared\" /ZW:nostdlib /Zi /Gm- /Od /sdl /Fd"ARM\Debug\vc120.pdb" /fp:precise /D "PSAPI_VERSION=2" /D "WINAPI_FAMILY=WINAPI_FAMILY_PHONE_APP" /D "_UITHREADCTXT_SUPPORT=0" /D "_UNICODE" /D "UNICODE" /D "_DEBUG" /errorReport:prompt /WX- /Zc:forScope /RTC1 /ZW /Gd /Oy- /MDd /Fa"ARM\Debug\" /EHsc /nologo /Fo"ARM\Debug\" /Fp"ARM\Debug\App2.WindowsPhone.pch" # debug: /Yu"pch.h" /MP /GS /analyze- /W3 /wd"4453" /wd"28204" /Zc:wchar_t /I"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\App2\App2.WindowsPhone\" /I"Generated Files\" /I"ARM\Debug\" /I"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\App2\App2.Shared\" /ZW:nostdlib /Zi /Gm- /Od /sdl /Fd"ARM\Debug\vc120.pdb" /fp:precise /D "PSAPI_VERSION=2" /D "WINAPI_FAMILY=WINAPI_FAMILY_PHONE_APP" /D "_UITHREADCTXT_SUPPORT=0" /D "_UNICODE" /D "UNICODE" /D "_DEBUG" /errorReport:prompt /WX- /Zc:forScope /RTC1 /ZW /Gd /Oy- /MDd /Fa"ARM\Debug\" /EHsc /nologo /Fo"ARM\Debug\" /Fp"ARM\Debug\App2.WindowsPhone.pch"
# release: /Yu"pch.h" /MP /GS /GL /analyze- /W3 /wd"4453" /wd"28204" /Gy /Zc:wchar_t /I"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\App2\App2.WindowsPhone\" /I"Generated Files\" /I"ARM\Release\" /I"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\App2\App2.Shared\" /ZW:nostdlib /Zi /Gm- /O2 /sdl /Fd"ARM\Release\vc120.pdb" /fp:precise /D "PSAPI_VERSION=2" /D "WINAPI_FAMILY=WINAPI_FAMILY_PHONE_APP" /D "_UITHREADCTXT_SUPPORT=0" /D "_UNICODE" /D "UNICODE" /errorReport:prompt /WX- /Zc:forScope /ZW /Gd /Oy- /Oi /MD /Fa"ARM\Release\" /EHsc /nologo /Fo"ARM\Release\" /Fp"ARM\Release\App2.WindowsPhone.pch" # release: /Yu"pch.h" /MP /GS /GL /analyze- /W3 /wd"4453" /wd"28204" /Gy /Zc:wchar_t /I"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\App2\App2.WindowsPhone\" /I"Generated Files\" /I"ARM\Release\" /I"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\App2\App2.Shared\" /ZW:nostdlib /Zi /Gm- /O2 /sdl /Fd"ARM\Release\vc120.pdb" /fp:precise /D "PSAPI_VERSION=2" /D "WINAPI_FAMILY=WINAPI_FAMILY_PHONE_APP" /D "_UITHREADCTXT_SUPPORT=0" /D "_UNICODE" /D "UNICODE" /errorReport:prompt /WX- /Zc:forScope /ZW /Gd /Oy- /Oi /MD /Fa"ARM\Release\" /EHsc /nologo /Fo"ARM\Release\" /Fp"ARM\Release\App2.WindowsPhone.pch"
# linker commandline # linker commandline
# debug: /OUT:"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\ARM\Debug\App2.WindowsPhone\App2.WindowsPhone.exe" /MANIFEST:NO /NXCOMPAT /PDB:"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\ARM\Debug\App2.WindowsPhone\App2.WindowsPhone.pdb" /DYNAMICBASE "WindowsPhoneCore.lib" "RuntimeObject.lib" "PhoneAppModelHost.lib" /DEBUG /MACHINE:ARM /NODEFAULTLIB:"kernel32.lib" /NODEFAULTLIB:"ole32.lib" /WINMD /APPCONTAINER /INCREMENTAL /PGD:"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\ARM\Debug\App2.WindowsPhone\App2.WindowsPhone.pgd" /WINMDFILE:"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\ARM\Debug\App2.WindowsPhone\App2.winmd" /SUBSYSTEM:WINDOWS /MANIFESTUAC:NO /ManifestFile:"ARM\Debug\App2.WindowsPhone.exe.intermediate.manifest" /ERRORREPORT:PROMPT /NOLOGO /TLBID:1 # debug: /OUT:"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\ARM\Debug\App2.WindowsPhone\App2.WindowsPhone.exe" /MANIFEST:NO /NXCOMPAT /PDB:"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\ARM\Debug\App2.WindowsPhone\App2.WindowsPhone.pdb" /DYNAMICBASE "WindowsPhoneCore.lib" "RuntimeObject.lib" "PhoneAppModelHost.lib" /DEBUG /MACHINE:ARM /NODEFAULTLIB:"kernel32.lib" /NODEFAULTLIB:"ole32.lib" /WINMD /APPCONTAINER /INCREMENTAL /PGD:"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\ARM\Debug\App2.WindowsPhone\App2.WindowsPhone.pgd" /WINMDFILE:"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\ARM\Debug\App2.WindowsPhone\App2.winmd" /SUBSYSTEM:WINDOWS /MANIFESTUAC:NO /ManifestFile:"ARM\Debug\App2.WindowsPhone.exe.intermediate.manifest" /ERRORREPORT:PROMPT /NOLOGO /TLBID:1
# release: /OUT:"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\ARM\Release\App2.WindowsPhone\App2.WindowsPhone.exe" /MANIFEST:NO /LTCG /NXCOMPAT /PDB:"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\ARM\Release\App2.WindowsPhone\App2.WindowsPhone.pdb" /DYNAMICBASE "WindowsPhoneCore.lib" "RuntimeObject.lib" "PhoneAppModelHost.lib" /DEBUG /MACHINE:ARM /NODEFAULTLIB:"kernel32.lib" /NODEFAULTLIB:"ole32.lib" /WINMD /APPCONTAINER /OPT:REF /PGD:"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\ARM\Release\App2.WindowsPhone\App2.WindowsPhone.pgd" /WINMDFILE:"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\ARM\Release\App2.WindowsPhone\App2.winmd" /SUBSYSTEM:WINDOWS /MANIFESTUAC:NO /ManifestFile:"ARM\Release\App2.WindowsPhone.exe.intermediate.manifest" /OPT:ICF /ERRORREPORT:PROMPT /NOLOGO /TLBID:1 # release: /OUT:"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\ARM\Release\App2.WindowsPhone\App2.WindowsPhone.exe" /MANIFEST:NO /LTCG /NXCOMPAT /PDB:"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\ARM\Release\App2.WindowsPhone\App2.WindowsPhone.pdb" /DYNAMICBASE "WindowsPhoneCore.lib" "RuntimeObject.lib" "PhoneAppModelHost.lib" /DEBUG /MACHINE:ARM /NODEFAULTLIB:"kernel32.lib" /NODEFAULTLIB:"ole32.lib" /WINMD /APPCONTAINER /OPT:REF /PGD:"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\ARM\Release\App2.WindowsPhone\App2.WindowsPhone.pgd" /WINMDFILE:"C:\Users\ariel\Documents\Visual Studio 2013\Projects\App2\ARM\Release\App2.WindowsPhone\App2.winmd" /SUBSYSTEM:WINDOWS /MANIFESTUAC:NO /ManifestFile:"ARM\Release\App2.WindowsPhone.exe.intermediate.manifest" /OPT:ICF /ERRORREPORT:PROMPT /NOLOGO /TLBID:1
arch = "arm" arch = "arm"
env.Append(LINKFLAGS=['/INCREMENTAL:NO', '/MANIFEST:NO', '/NXCOMPAT', '/DYNAMICBASE', "WindowsPhoneCore.lib", "RuntimeObject.lib", "PhoneAppModelHost.lib", "/DEBUG", "/MACHINE:ARM", '/NODEFAULTLIB:"kernel32.lib"', '/NODEFAULTLIB:"ole32.lib"', '/WINMD', '/APPCONTAINER', '/MANIFESTUAC:NO', '/ERRORREPORT:PROMPT', '/NOLOGO', '/TLBID:1']) env.Append(LINKFLAGS=['/INCREMENTAL:NO', '/MANIFEST:NO', '/NXCOMPAT', '/DYNAMICBASE', "WindowsPhoneCore.lib", "RuntimeObject.lib", "PhoneAppModelHost.lib", "/DEBUG", "/MACHINE:ARM", '/NODEFAULTLIB:"kernel32.lib"', '/NODEFAULTLIB:"ole32.lib"', '/WINMD', '/APPCONTAINER', '/MANIFESTUAC:NO', '/ERRORREPORT:PROMPT', '/NOLOGO', '/TLBID:1'])
env.Append(LIBPATH=['#platform/winrt/ARM/lib']) env.Append(LIBPATH=['#platform/winrt/ARM/lib'])
env.Append(CCFLAGS=string.split('/MP /GS /wd"4453" /wd"28204" /analyze- /Zc:wchar_t /Zi /Gm- /Od /fp:precise /fp:precise /D "PSAPI_VERSION=2" /D "WINAPI_FAMILY=WINAPI_FAMILY_PHONE_APP" /DWINDOWSPHONE_ENABLED /D "_UITHREADCTXT_SUPPORT=0" /D "_UNICODE" /D "UNICODE" /errorReport:prompt /WX- /Zc:forScope /Gd /Oy- /Oi /MD /RTC1 /Gd /EHsc /nologo')) env.Append(CCFLAGS=string.split('/MP /GS /wd"4453" /wd"28204" /analyze- /Zc:wchar_t /Zi /Gm- /Od /fp:precise /fp:precise /D "PSAPI_VERSION=2" /D "WINAPI_FAMILY=WINAPI_FAMILY_PHONE_APP" /DWINDOWSPHONE_ENABLED /D "_UITHREADCTXT_SUPPORT=0" /D "_UNICODE" /D "UNICODE" /errorReport:prompt /WX- /Zc:forScope /Gd /Oy- /Oi /MD /RTC1 /Gd /EHsc /nologo'))
env.Append(CXXFLAGS=string.split('/ZW')) env.Append(CXXFLAGS=string.split('/ZW'))
if (env["target"]=="release"): if (env["target"]=="release"):
env.Append(CCFLAGS=['/O2']) env.Append(CCFLAGS=['/O2'])
env.Append(LINKFLAGS=['/SUBSYSTEM:WINDOWS']) env.Append(LINKFLAGS=['/SUBSYSTEM:WINDOWS'])
elif (env["target"]=="test"): elif (env["target"]=="test"):
env.Append(CCFLAGS=['/O2','/DDEBUG_ENABLED','/DD3D_DEBUG_INFO']) env.Append(CCFLAGS=['/O2','/DDEBUG_ENABLED','/DD3D_DEBUG_INFO'])
env.Append(LINKFLAGS=['/SUBSYSTEM:CONSOLE']) env.Append(LINKFLAGS=['/SUBSYSTEM:CONSOLE'])
elif (env["target"]=="debug"): elif (env["target"]=="debug"):
env.Append(CCFLAGS=['/Zi','/DDEBUG_ENABLED','/DD3D_DEBUG_INFO']) env.Append(CCFLAGS=['/Zi','/DDEBUG_ENABLED','/DD3D_DEBUG_INFO'])
env.Append(LINKFLAGS=['/SUBSYSTEM:CONSOLE']) env.Append(LINKFLAGS=['/SUBSYSTEM:CONSOLE'])
env.Append(LINKFLAGS=['/DEBUG', '/D_DEBUG']) env.Append(LINKFLAGS=['/DEBUG', '/D_DEBUG'])
elif (env["target"]=="profile"): elif (env["target"]=="profile"):
env.Append(CCFLAGS=['-g','-pg']) env.Append(CCFLAGS=['-g','-pg'])
env.Append(LINKFLAGS=['-pg']) env.Append(LINKFLAGS=['-pg'])
env['ENV'] = os.environ; env['ENV'] = os.environ;
# fix environment for windows phone 8.1 # fix environment for windows phone 8.1
env['ENV']['WINDOWSPHONEKITDIR'] = env['ENV']['WINDOWSPHONEKITDIR'].replace("8.0", "8.1") # wtf env['ENV']['WINDOWSPHONEKITDIR'] = env['ENV']['WINDOWSPHONEKITDIR'].replace("8.0", "8.1") # wtf
env['ENV']['INCLUDE'] = env['ENV']['INCLUDE'].replace("8.0", "8.1") env['ENV']['INCLUDE'] = env['ENV']['INCLUDE'].replace("8.0", "8.1")
env['ENV']['LIB'] = env['ENV']['LIB'].replace("8.0", "8.1") env['ENV']['LIB'] = env['ENV']['LIB'].replace("8.0", "8.1")
env['ENV']['PATH'] = env['ENV']['PATH'].replace("8.0", "8.1") env['ENV']['PATH'] = env['ENV']['PATH'].replace("8.0", "8.1")
env['ENV']['LIBPATH'] = env['ENV']['LIBPATH'].replace("8.0\\Windows Metadata", "8.1\\References\\CommonConfiguration\\Neutral") env['ENV']['LIBPATH'] = env['ENV']['LIBPATH'].replace("8.0\\Windows Metadata", "8.1\\References\\CommonConfiguration\\Neutral")
else: else:
arch = "x64" arch = "x64"
env.Append(LINKFLAGS=['/MANIFEST:NO', '/NXCOMPAT', '/DYNAMICBASE', "kernel32.lib", '/MACHINE:X64', '/WINMD', '/APPCONTAINER', '/MANIFESTUAC:NO', '/ERRORREPORT:PROMPT', '/NOLOGO', '/TLBID:1']) env.Append(LINKFLAGS=['/MANIFEST:NO', '/NXCOMPAT', '/DYNAMICBASE', "kernel32.lib", '/MACHINE:X64', '/WINMD', '/APPCONTAINER', '/MANIFESTUAC:NO', '/ERRORREPORT:PROMPT', '/NOLOGO', '/TLBID:1'])
env.Append(LIBPATH=['#platform/winrt/x64/lib']) env.Append(LIBPATH=['#platform/winrt/x64/lib'])
if (env["target"]=="release"): if (env["target"]=="release"):
env.Append(CCFLAGS=['/O2']) env.Append(CCFLAGS=['/O2'])
env.Append(LINKFLAGS=['/SUBSYSTEM:WINDOWS']) env.Append(LINKFLAGS=['/SUBSYSTEM:WINDOWS'])
env.Append(LINKFLAGS=['/ENTRY:mainCRTStartup']) env.Append(LINKFLAGS=['/ENTRY:mainCRTStartup'])
elif (env["target"]=="test"): elif (env["target"]=="test"):
env.Append(CCFLAGS=['/O2','/DDEBUG_ENABLED','/DD3D_DEBUG_INFO']) env.Append(CCFLAGS=['/O2','/DDEBUG_ENABLED','/DD3D_DEBUG_INFO'])
env.Append(LINKFLAGS=['/SUBSYSTEM:CONSOLE']) env.Append(LINKFLAGS=['/SUBSYSTEM:CONSOLE'])
elif (env["target"]=="debug"): elif (env["target"]=="debug"):
env.Append(CCFLAGS=['/Zi','/DDEBUG_ENABLED','/DD3D_DEBUG_INFO']) env.Append(CCFLAGS=['/Zi','/DDEBUG_ENABLED','/DD3D_DEBUG_INFO'])
env.Append(LINKFLAGS=['/SUBSYSTEM:CONSOLE']) env.Append(LINKFLAGS=['/SUBSYSTEM:CONSOLE'])
env.Append(LINKFLAGS=['/DEBUG', '/D_DEBUG']) env.Append(LINKFLAGS=['/DEBUG', '/D_DEBUG'])
elif (env["target"]=="profile"): elif (env["target"]=="profile"):
env.Append(CCFLAGS=['-g','-pg']) env.Append(CCFLAGS=['-g','-pg'])
env.Append(LINKFLAGS=['-pg']) env.Append(LINKFLAGS=['-pg'])
env.Append(CCFLAGS=string.split('/MP /GS /wd"4453" /wd"28204" /Zc:wchar_t /Gm- /Od /fp:precise /D "_UNICODE" /D "UNICODE" /D "WINAPI_FAMILY=WINAPI_FAMILY_APP" /errorReport:prompt /WX- /Zc:forScope /RTC1 /Gd /MDd /EHsc /nologo')) env.Append(CCFLAGS=string.split('/MP /GS /wd"4453" /wd"28204" /Zc:wchar_t /Gm- /Od /fp:precise /D "_UNICODE" /D "UNICODE" /D "WINAPI_FAMILY=WINAPI_FAMILY_APP" /errorReport:prompt /WX- /Zc:forScope /RTC1 /Gd /MDd /EHsc /nologo'))
env.Append(CXXFLAGS=string.split('/ZW')) env.Append(CXXFLAGS=string.split('/ZW'))
env.Append(CCFLAGS=['/AI', os.environ['VCINSTALLDIR']+'\\vcpackages', '/AI', os.environ['WINDOWSSDKDIR']+'\\References\\CommonConfiguration\\Neutral']) env.Append(CCFLAGS=['/AI', os.environ['VCINSTALLDIR']+'\\vcpackages', '/AI', os.environ['WINDOWSSDKDIR']+'\\References\\CommonConfiguration\\Neutral'])
env.Append(CCFLAGS=['/DWINAPI_FAMILY=WINAPI_FAMILY_APP', '/D_WIN32_WINNT=0x0603', '/DNTDDI_VERSION=0x06030000']) env.Append(CCFLAGS=['/DWINAPI_FAMILY=WINAPI_FAMILY_APP', '/D_WIN32_WINNT=0x0603', '/DNTDDI_VERSION=0x06030000'])
env['ENV'] = os.environ; env['ENV'] = os.environ;
env["PROGSUFFIX"]="."+arch+env["PROGSUFFIX"] env["PROGSUFFIX"]="."+arch+env["PROGSUFFIX"]
env["OBJSUFFIX"]="."+arch+env["OBJSUFFIX"] env["OBJSUFFIX"]="."+arch+env["OBJSUFFIX"]
env["LIBSUFFIX"]="."+arch+env["LIBSUFFIX"] env["LIBSUFFIX"]="."+arch+env["LIBSUFFIX"]
#env.Append(CCFLAGS=['/Gd','/GR','/nologo', '/EHsc']) #env.Append(CCFLAGS=['/Gd','/GR','/nologo', '/EHsc'])
#env.Append(CXXFLAGS=['/TP', '/ZW']) #env.Append(CXXFLAGS=['/TP', '/ZW'])
#env.Append(CPPFLAGS=['/DMSVC', '/GR', ]) #env.Append(CPPFLAGS=['/DMSVC', '/GR', ])
##env.Append(CCFLAGS=['/I'+os.getenv("WindowsSdkDir")+"/Include"]) ##env.Append(CCFLAGS=['/I'+os.getenv("WindowsSdkDir")+"/Include"])
env.Append(CCFLAGS=['/DWINRT_ENABLED']) env.Append(CCFLAGS=['/DWINRT_ENABLED'])
env.Append(CCFLAGS=['/DWINDOWS_ENABLED']) env.Append(CCFLAGS=['/DWINDOWS_ENABLED'])
env.Append(CCFLAGS=['/DRTAUDIO_ENABLED']) env.Append(CCFLAGS=['/DRTAUDIO_ENABLED'])
#env.Append(CCFLAGS=['/DWIN32']) #env.Append(CCFLAGS=['/DWIN32'])
env.Append(CCFLAGS=['/DTYPED_METHOD_BIND']) env.Append(CCFLAGS=['/DTYPED_METHOD_BIND'])
env.Append(CCFLAGS=['/DGLES2_ENABLED']) env.Append(CCFLAGS=['/DGLES2_ENABLED'])
#env.Append(CCFLAGS=['/DGLES1_ENABLED']) #env.Append(CCFLAGS=['/DGLES1_ENABLED'])
LIBS=[ LIBS=[
#'winmm', #'winmm',
'libEGL', 'libEGL',
'libGLESv2', 'libGLESv2',
'libANGLE', 'libANGLE',
#'kernel32','ole32','user32', 'advapi32' #'kernel32','ole32','user32', 'advapi32'
] ]
env.Append(LINKFLAGS=[p+".lib" for p in LIBS]) env.Append(LINKFLAGS=[p+".lib" for p in LIBS])
import methods import methods
env.Append( BUILDERS = { 'GLSL120' : env.Builder(action = methods.build_legacygl_headers, suffix = 'glsl.h',src_suffix = '.glsl') } ) env.Append( BUILDERS = { 'GLSL120' : env.Builder(action = methods.build_legacygl_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
env.Append( BUILDERS = { 'GLSL' : env.Builder(action = methods.build_glsl_headers, suffix = 'glsl.h',src_suffix = '.glsl') } ) env.Append( BUILDERS = { 'GLSL' : env.Builder(action = methods.build_glsl_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
env.Append( BUILDERS = { 'HLSL9' : env.Builder(action = methods.build_hlsl_dx9_headers, suffix = 'hlsl.h',src_suffix = '.hlsl') } ) env.Append( BUILDERS = { 'HLSL9' : env.Builder(action = methods.build_hlsl_dx9_headers, suffix = 'hlsl.h',src_suffix = '.hlsl') } )
env.Append( BUILDERS = { 'GLSL120GLES' : env.Builder(action = methods.build_gles2_headers, suffix = 'glsl.h',src_suffix = '.glsl') } ) env.Append( BUILDERS = { 'GLSL120GLES' : env.Builder(action = methods.build_gles2_headers, suffix = 'glsl.h',src_suffix = '.glsl') } )
#/c/Program Files (x86)/Windows Phone Kits/8.1/lib/ARM/WindowsPhoneCore.lib #/c/Program Files (x86)/Windows Phone Kits/8.1/lib/ARM/WindowsPhoneCore.lib

596
platform/winrt/include/EGL/egl.h
View file

@ -1,298 +1,298 @@
#ifndef __egl_h_ #ifndef __egl_h_
#define __egl_h_ 1 #define __egl_h_ 1
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
/* /*
** Copyright (c) 2013-2014 The Khronos Group Inc. ** Copyright (c) 2013-2014 The Khronos Group Inc.
** **
** Permission is hereby granted, free of charge, to any person obtaining a ** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the ** copy of this software and/or associated documentation files (the
** "Materials"), to deal in the Materials without restriction, including ** "Materials"), to deal in the Materials without restriction, including
** without limitation the rights to use, copy, modify, merge, publish, ** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Materials, and to ** distribute, sublicense, and/or sell copies of the Materials, and to
** permit persons to whom the Materials are furnished to do so, subject to ** permit persons to whom the Materials are furnished to do so, subject to
** the following conditions: ** the following conditions:
** **
** The above copyright notice and this permission notice shall be included ** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Materials. ** in all copies or substantial portions of the Materials.
** **
** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/ */
/* /*
** This header is generated from the Khronos OpenGL / OpenGL ES XML ** This header is generated from the Khronos OpenGL / OpenGL ES XML
** API Registry. The current version of the Registry, generator scripts ** API Registry. The current version of the Registry, generator scripts
** used to make the header, and the header can be found at ** used to make the header, and the header can be found at
** http://www.opengl.org/registry/ ** http://www.opengl.org/registry/
** **
** Khronos $Revision: 27018 $ on $Date: 2014-06-10 08:06:12 -0700 (Tue, 10 Jun 2014) $ ** Khronos $Revision: 27018 $ on $Date: 2014-06-10 08:06:12 -0700 (Tue, 10 Jun 2014) $
*/ */
#include <EGL/eglplatform.h> #include <EGL/eglplatform.h>
/* Generated on date 20140610 */ /* Generated on date 20140610 */
/* Generated C header for: /* Generated C header for:
* API: egl * API: egl
* Versions considered: .* * Versions considered: .*
* Versions emitted: .* * Versions emitted: .*
* Default extensions included: None * Default extensions included: None
* Additional extensions included: _nomatch_^ * Additional extensions included: _nomatch_^
* Extensions removed: _nomatch_^ * Extensions removed: _nomatch_^
*/ */
#ifndef EGL_VERSION_1_0 #ifndef EGL_VERSION_1_0
#define EGL_VERSION_1_0 1 #define EGL_VERSION_1_0 1
typedef unsigned int EGLBoolean; typedef unsigned int EGLBoolean;
typedef void *EGLDisplay; typedef void *EGLDisplay;
#include <KHR/khrplatform.h> #include <KHR/khrplatform.h>
#include <EGL/eglplatform.h> #include <EGL/eglplatform.h>
typedef void *EGLConfig; typedef void *EGLConfig;
typedef void *EGLSurface; typedef void *EGLSurface;
typedef void *EGLContext; typedef void *EGLContext;
typedef void (*__eglMustCastToProperFunctionPointerType)(void); typedef void (*__eglMustCastToProperFunctionPointerType)(void);
#define EGL_ALPHA_SIZE 0x3021 #define EGL_ALPHA_SIZE 0x3021
#define EGL_BAD_ACCESS 0x3002 #define EGL_BAD_ACCESS 0x3002
#define EGL_BAD_ALLOC 0x3003 #define EGL_BAD_ALLOC 0x3003
#define EGL_BAD_ATTRIBUTE 0x3004 #define EGL_BAD_ATTRIBUTE 0x3004
#define EGL_BAD_CONFIG 0x3005 #define EGL_BAD_CONFIG 0x3005
#define EGL_BAD_CONTEXT 0x3006 #define EGL_BAD_CONTEXT 0x3006
#define EGL_BAD_CURRENT_SURFACE 0x3007 #define EGL_BAD_CURRENT_SURFACE 0x3007
#define EGL_BAD_DISPLAY 0x3008 #define EGL_BAD_DISPLAY 0x3008
#define EGL_BAD_MATCH 0x3009 #define EGL_BAD_MATCH 0x3009
#define EGL_BAD_NATIVE_PIXMAP 0x300A #define EGL_BAD_NATIVE_PIXMAP 0x300A
#define EGL_BAD_NATIVE_WINDOW 0x300B #define EGL_BAD_NATIVE_WINDOW 0x300B
#define EGL_BAD_PARAMETER 0x300C #define EGL_BAD_PARAMETER 0x300C
#define EGL_BAD_SURFACE 0x300D #define EGL_BAD_SURFACE 0x300D
#define EGL_BLUE_SIZE 0x3022 #define EGL_BLUE_SIZE 0x3022
#define EGL_BUFFER_SIZE 0x3020 #define EGL_BUFFER_SIZE 0x3020
#define EGL_CONFIG_CAVEAT 0x3027 #define EGL_CONFIG_CAVEAT 0x3027
#define EGL_CONFIG_ID 0x3028 #define EGL_CONFIG_ID 0x3028
#define EGL_CORE_NATIVE_ENGINE 0x305B #define EGL_CORE_NATIVE_ENGINE 0x305B
#define EGL_DEPTH_SIZE 0x3025 #define EGL_DEPTH_SIZE 0x3025
#define EGL_DONT_CARE ((EGLint)-1) #define EGL_DONT_CARE ((EGLint)-1)
#define EGL_DRAW 0x3059 #define EGL_DRAW 0x3059
#define EGL_EXTENSIONS 0x3055 #define EGL_EXTENSIONS 0x3055
#define EGL_FALSE 0 #define EGL_FALSE 0
#define EGL_GREEN_SIZE 0x3023 #define EGL_GREEN_SIZE 0x3023
#define EGL_HEIGHT 0x3056 #define EGL_HEIGHT 0x3056
#define EGL_LARGEST_PBUFFER 0x3058 #define EGL_LARGEST_PBUFFER 0x3058
#define EGL_LEVEL 0x3029 #define EGL_LEVEL 0x3029
#define EGL_MAX_PBUFFER_HEIGHT 0x302A #define EGL_MAX_PBUFFER_HEIGHT 0x302A
#define EGL_MAX_PBUFFER_PIXELS 0x302B #define EGL_MAX_PBUFFER_PIXELS 0x302B
#define EGL_MAX_PBUFFER_WIDTH 0x302C #define EGL_MAX_PBUFFER_WIDTH 0x302C
#define EGL_NATIVE_RENDERABLE 0x302D #define EGL_NATIVE_RENDERABLE 0x302D
#define EGL_NATIVE_VISUAL_ID 0x302E #define EGL_NATIVE_VISUAL_ID 0x302E
#define EGL_NATIVE_VISUAL_TYPE 0x302F #define EGL_NATIVE_VISUAL_TYPE 0x302F
#define EGL_NONE 0x3038 #define EGL_NONE 0x3038
#define EGL_NON_CONFORMANT_CONFIG 0x3051 #define EGL_NON_CONFORMANT_CONFIG 0x3051
#define EGL_NOT_INITIALIZED 0x3001 #define EGL_NOT_INITIALIZED 0x3001
#define EGL_NO_CONTEXT ((EGLContext)0) #define EGL_NO_CONTEXT ((EGLContext)0)
#define EGL_NO_DISPLAY ((EGLDisplay)0) #define EGL_NO_DISPLAY ((EGLDisplay)0)
#define EGL_NO_SURFACE ((EGLSurface)0) #define EGL_NO_SURFACE ((EGLSurface)0)
#define EGL_PBUFFER_BIT 0x0001 #define EGL_PBUFFER_BIT 0x0001
#define EGL_PIXMAP_BIT 0x0002 #define EGL_PIXMAP_BIT 0x0002
#define EGL_READ 0x305A #define EGL_READ 0x305A
#define EGL_RED_SIZE 0x3024 #define EGL_RED_SIZE 0x3024
#define EGL_SAMPLES 0x3031 #define EGL_SAMPLES 0x3031
#define EGL_SAMPLE_BUFFERS 0x3032 #define EGL_SAMPLE_BUFFERS 0x3032
#define EGL_SLOW_CONFIG 0x3050 #define EGL_SLOW_CONFIG 0x3050
#define EGL_STENCIL_SIZE 0x3026 #define EGL_STENCIL_SIZE 0x3026
#define EGL_SUCCESS 0x3000 #define EGL_SUCCESS 0x3000
#define EGL_SURFACE_TYPE 0x3033 #define EGL_SURFACE_TYPE 0x3033
#define EGL_TRANSPARENT_BLUE_VALUE 0x3035 #define EGL_TRANSPARENT_BLUE_VALUE 0x3035
#define EGL_TRANSPARENT_GREEN_VALUE 0x3036 #define EGL_TRANSPARENT_GREEN_VALUE 0x3036
#define EGL_TRANSPARENT_RED_VALUE 0x3037 #define EGL_TRANSPARENT_RED_VALUE 0x3037
#define EGL_TRANSPARENT_RGB 0x3052 #define EGL_TRANSPARENT_RGB 0x3052
#define EGL_TRANSPARENT_TYPE 0x3034 #define EGL_TRANSPARENT_TYPE 0x3034
#define EGL_TRUE 1 #define EGL_TRUE 1
#define EGL_VENDOR 0x3053 #define EGL_VENDOR 0x3053
#define EGL_VERSION 0x3054 #define EGL_VERSION 0x3054
#define EGL_WIDTH 0x3057 #define EGL_WIDTH 0x3057
#define EGL_WINDOW_BIT 0x0004 #define EGL_WINDOW_BIT 0x0004
EGLAPI EGLBoolean EGLAPIENTRY eglChooseConfig (EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config); EGLAPI EGLBoolean EGLAPIENTRY eglChooseConfig (EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config);
EGLAPI EGLBoolean EGLAPIENTRY eglCopyBuffers (EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target); EGLAPI EGLBoolean EGLAPIENTRY eglCopyBuffers (EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target);
EGLAPI EGLContext EGLAPIENTRY eglCreateContext (EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list); EGLAPI EGLContext EGLAPIENTRY eglCreateContext (EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list);
EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferSurface (EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list); EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferSurface (EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list);
EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurface (EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list); EGLAPI EGLSurface EGLAPIENTRY eglCreatePixmapSurface (EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list);
EGLAPI EGLSurface EGLAPIENTRY eglCreateWindowSurface (EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list); EGLAPI EGLSurface EGLAPIENTRY eglCreateWindowSurface (EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list);
EGLAPI EGLBoolean EGLAPIENTRY eglDestroyContext (EGLDisplay dpy, EGLContext ctx); EGLAPI EGLBoolean EGLAPIENTRY eglDestroyContext (EGLDisplay dpy, EGLContext ctx);
EGLAPI EGLBoolean EGLAPIENTRY eglDestroySurface (EGLDisplay dpy, EGLSurface surface); EGLAPI EGLBoolean EGLAPIENTRY eglDestroySurface (EGLDisplay dpy, EGLSurface surface);
EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigAttrib (EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value); EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigAttrib (EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value);
EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigs (EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config); EGLAPI EGLBoolean EGLAPIENTRY eglGetConfigs (EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config);
EGLAPI EGLDisplay EGLAPIENTRY eglGetCurrentDisplay (void); EGLAPI EGLDisplay EGLAPIENTRY eglGetCurrentDisplay (void);
EGLAPI EGLSurface EGLAPIENTRY eglGetCurrentSurface (EGLint readdraw); EGLAPI EGLSurface EGLAPIENTRY eglGetCurrentSurface (EGLint readdraw);
EGLAPI EGLDisplay EGLAPIENTRY eglGetDisplay (EGLNativeDisplayType display_id); EGLAPI EGLDisplay EGLAPIENTRY eglGetDisplay (EGLNativeDisplayType display_id);
EGLAPI EGLint EGLAPIENTRY eglGetError (void); EGLAPI EGLint EGLAPIENTRY eglGetError (void);
EGLAPI __eglMustCastToProperFunctionPointerType EGLAPIENTRY eglGetProcAddress (const char *procname); EGLAPI __eglMustCastToProperFunctionPointerType EGLAPIENTRY eglGetProcAddress (const char *procname);
EGLAPI EGLBoolean EGLAPIENTRY eglInitialize (EGLDisplay dpy, EGLint *major, EGLint *minor); EGLAPI EGLBoolean EGLAPIENTRY eglInitialize (EGLDisplay dpy, EGLint *major, EGLint *minor);
EGLAPI EGLBoolean EGLAPIENTRY eglMakeCurrent (EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx); EGLAPI EGLBoolean EGLAPIENTRY eglMakeCurrent (EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx);
EGLAPI EGLBoolean EGLAPIENTRY eglQueryContext (EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value); EGLAPI EGLBoolean EGLAPIENTRY eglQueryContext (EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value);
EGLAPI const char *EGLAPIENTRY eglQueryString (EGLDisplay dpy, EGLint name); EGLAPI const char *EGLAPIENTRY eglQueryString (EGLDisplay dpy, EGLint name);
EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurface (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value); EGLAPI EGLBoolean EGLAPIENTRY eglQuerySurface (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value);
EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffers (EGLDisplay dpy, EGLSurface surface); EGLAPI EGLBoolean EGLAPIENTRY eglSwapBuffers (EGLDisplay dpy, EGLSurface surface);
EGLAPI EGLBoolean EGLAPIENTRY eglTerminate (EGLDisplay dpy); EGLAPI EGLBoolean EGLAPIENTRY eglTerminate (EGLDisplay dpy);
EGLAPI EGLBoolean EGLAPIENTRY eglWaitGL (void); EGLAPI EGLBoolean EGLAPIENTRY eglWaitGL (void);
EGLAPI EGLBoolean EGLAPIENTRY eglWaitNative (EGLint engine); EGLAPI EGLBoolean EGLAPIENTRY eglWaitNative (EGLint engine);
#endif /* EGL_VERSION_1_0 */ #endif /* EGL_VERSION_1_0 */
#ifndef EGL_VERSION_1_1 #ifndef EGL_VERSION_1_1
#define EGL_VERSION_1_1 1 #define EGL_VERSION_1_1 1
#define EGL_BACK_BUFFER 0x3084 #define EGL_BACK_BUFFER 0x3084
#define EGL_BIND_TO_TEXTURE_RGB 0x3039 #define EGL_BIND_TO_TEXTURE_RGB 0x3039
#define EGL_BIND_TO_TEXTURE_RGBA 0x303A #define EGL_BIND_TO_TEXTURE_RGBA 0x303A
#define EGL_CONTEXT_LOST 0x300E #define EGL_CONTEXT_LOST 0x300E
#define EGL_MIN_SWAP_INTERVAL 0x303B #define EGL_MIN_SWAP_INTERVAL 0x303B
#define EGL_MAX_SWAP_INTERVAL 0x303C #define EGL_MAX_SWAP_INTERVAL 0x303C
#define EGL_MIPMAP_TEXTURE 0x3082 #define EGL_MIPMAP_TEXTURE 0x3082
#define EGL_MIPMAP_LEVEL 0x3083 #define EGL_MIPMAP_LEVEL 0x3083
#define EGL_NO_TEXTURE 0x305C #define EGL_NO_TEXTURE 0x305C
#define EGL_TEXTURE_2D 0x305F #define EGL_TEXTURE_2D 0x305F
#define EGL_TEXTURE_FORMAT 0x3080 #define EGL_TEXTURE_FORMAT 0x3080
#define EGL_TEXTURE_RGB 0x305D #define EGL_TEXTURE_RGB 0x305D
#define EGL_TEXTURE_RGBA 0x305E #define EGL_TEXTURE_RGBA 0x305E
#define EGL_TEXTURE_TARGET 0x3081 #define EGL_TEXTURE_TARGET 0x3081
EGLAPI EGLBoolean EGLAPIENTRY eglBindTexImage (EGLDisplay dpy, EGLSurface surface, EGLint buffer); EGLAPI EGLBoolean EGLAPIENTRY eglBindTexImage (EGLDisplay dpy, EGLSurface surface, EGLint buffer);
EGLAPI EGLBoolean EGLAPIENTRY eglReleaseTexImage (EGLDisplay dpy, EGLSurface surface, EGLint buffer); EGLAPI EGLBoolean EGLAPIENTRY eglReleaseTexImage (EGLDisplay dpy, EGLSurface surface, EGLint buffer);
EGLAPI EGLBoolean EGLAPIENTRY eglSurfaceAttrib (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value); EGLAPI EGLBoolean EGLAPIENTRY eglSurfaceAttrib (EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value);
EGLAPI EGLBoolean EGLAPIENTRY eglSwapInterval (EGLDisplay dpy, EGLint interval); EGLAPI EGLBoolean EGLAPIENTRY eglSwapInterval (EGLDisplay dpy, EGLint interval);
#endif /* EGL_VERSION_1_1 */ #endif /* EGL_VERSION_1_1 */
#ifndef EGL_VERSION_1_2 #ifndef EGL_VERSION_1_2
#define EGL_VERSION_1_2 1 #define EGL_VERSION_1_2 1
typedef unsigned int EGLenum; typedef unsigned int EGLenum;
typedef void *EGLClientBuffer; typedef void *EGLClientBuffer;
#define EGL_ALPHA_FORMAT 0x3088 #define EGL_ALPHA_FORMAT 0x3088
#define EGL_ALPHA_FORMAT_NONPRE 0x308B #define EGL_ALPHA_FORMAT_NONPRE 0x308B
#define EGL_ALPHA_FORMAT_PRE 0x308C #define EGL_ALPHA_FORMAT_PRE 0x308C
#define EGL_ALPHA_MASK_SIZE 0x303E #define EGL_ALPHA_MASK_SIZE 0x303E
#define EGL_BUFFER_PRESERVED 0x3094 #define EGL_BUFFER_PRESERVED 0x3094
#define EGL_BUFFER_DESTROYED 0x3095 #define EGL_BUFFER_DESTROYED 0x3095
#define EGL_CLIENT_APIS 0x308D #define EGL_CLIENT_APIS 0x308D
#define EGL_COLORSPACE 0x3087 #define EGL_COLORSPACE 0x3087
#define EGL_COLORSPACE_sRGB 0x3089 #define EGL_COLORSPACE_sRGB 0x3089
#define EGL_COLORSPACE_LINEAR 0x308A #define EGL_COLORSPACE_LINEAR 0x308A
#define EGL_COLOR_BUFFER_TYPE 0x303F #define EGL_COLOR_BUFFER_TYPE 0x303F
#define EGL_CONTEXT_CLIENT_TYPE 0x3097 #define EGL_CONTEXT_CLIENT_TYPE 0x3097
#define EGL_DISPLAY_SCALING 10000 #define EGL_DISPLAY_SCALING 10000
#define EGL_HORIZONTAL_RESOLUTION 0x3090 #define EGL_HORIZONTAL_RESOLUTION 0x3090
#define EGL_LUMINANCE_BUFFER 0x308F #define EGL_LUMINANCE_BUFFER 0x308F
#define EGL_LUMINANCE_SIZE 0x303D #define EGL_LUMINANCE_SIZE 0x303D
#define EGL_OPENGL_ES_BIT 0x0001 #define EGL_OPENGL_ES_BIT 0x0001
#define EGL_OPENVG_BIT 0x0002 #define EGL_OPENVG_BIT 0x0002
#define EGL_OPENGL_ES_API 0x30A0 #define EGL_OPENGL_ES_API 0x30A0
#define EGL_OPENVG_API 0x30A1 #define EGL_OPENVG_API 0x30A1
#define EGL_OPENVG_IMAGE 0x3096 #define EGL_OPENVG_IMAGE 0x3096
#define EGL_PIXEL_ASPECT_RATIO 0x3092 #define EGL_PIXEL_ASPECT_RATIO 0x3092
#define EGL_RENDERABLE_TYPE 0x3040 #define EGL_RENDERABLE_TYPE 0x3040
#define EGL_RENDER_BUFFER 0x3086 #define EGL_RENDER_BUFFER 0x3086
#define EGL_RGB_BUFFER 0x308E #define EGL_RGB_BUFFER 0x308E
#define EGL_SINGLE_BUFFER 0x3085 #define EGL_SINGLE_BUFFER 0x3085
#define EGL_SWAP_BEHAVIOR 0x3093 #define EGL_SWAP_BEHAVIOR 0x3093
#define EGL_UNKNOWN ((EGLint)-1) #define EGL_UNKNOWN ((EGLint)-1)
#define EGL_VERTICAL_RESOLUTION 0x3091 #define EGL_VERTICAL_RESOLUTION 0x3091
EGLAPI EGLBoolean EGLAPIENTRY eglBindAPI (EGLenum api); EGLAPI EGLBoolean EGLAPIENTRY eglBindAPI (EGLenum api);
EGLAPI EGLenum EGLAPIENTRY eglQueryAPI (void); EGLAPI EGLenum EGLAPIENTRY eglQueryAPI (void);
EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferFromClientBuffer (EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list); EGLAPI EGLSurface EGLAPIENTRY eglCreatePbufferFromClientBuffer (EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list);
EGLAPI EGLBoolean EGLAPIENTRY eglReleaseThread (void); EGLAPI EGLBoolean EGLAPIENTRY eglReleaseThread (void);
EGLAPI EGLBoolean EGLAPIENTRY eglWaitClient (void); EGLAPI EGLBoolean EGLAPIENTRY eglWaitClient (void);
#endif /* EGL_VERSION_1_2 */ #endif /* EGL_VERSION_1_2 */
#ifndef EGL_VERSION_1_3 #ifndef EGL_VERSION_1_3
#define EGL_VERSION_1_3 1 #define EGL_VERSION_1_3 1
#define EGL_CONFORMANT 0x3042 #define EGL_CONFORMANT 0x3042
#define EGL_CONTEXT_CLIENT_VERSION 0x3098 #define EGL_CONTEXT_CLIENT_VERSION 0x3098
#define EGL_MATCH_NATIVE_PIXMAP 0x3041 #define EGL_MATCH_NATIVE_PIXMAP 0x3041
#define EGL_OPENGL_ES2_BIT 0x0004 #define EGL_OPENGL_ES2_BIT 0x0004
#define EGL_VG_ALPHA_FORMAT 0x3088 #define EGL_VG_ALPHA_FORMAT 0x3088
#define EGL_VG_ALPHA_FORMAT_NONPRE 0x308B #define EGL_VG_ALPHA_FORMAT_NONPRE 0x308B
#define EGL_VG_ALPHA_FORMAT_PRE 0x308C #define EGL_VG_ALPHA_FORMAT_PRE 0x308C
#define EGL_VG_ALPHA_FORMAT_PRE_BIT 0x0040 #define EGL_VG_ALPHA_FORMAT_PRE_BIT 0x0040
#define EGL_VG_COLORSPACE 0x3087 #define EGL_VG_COLORSPACE 0x3087
#define EGL_VG_COLORSPACE_sRGB 0x3089 #define EGL_VG_COLORSPACE_sRGB 0x3089
#define EGL_VG_COLORSPACE_LINEAR 0x308A #define EGL_VG_COLORSPACE_LINEAR 0x308A
#define EGL_VG_COLORSPACE_LINEAR_BIT 0x0020 #define EGL_VG_COLORSPACE_LINEAR_BIT 0x0020
#endif /* EGL_VERSION_1_3 */ #endif /* EGL_VERSION_1_3 */
#ifndef EGL_VERSION_1_4 #ifndef EGL_VERSION_1_4
#define EGL_VERSION_1_4 1 #define EGL_VERSION_1_4 1
#define EGL_DEFAULT_DISPLAY ((EGLNativeDisplayType)0) #define EGL_DEFAULT_DISPLAY ((EGLNativeDisplayType)0)
#define EGL_MULTISAMPLE_RESOLVE_BOX_BIT 0x0200 #define EGL_MULTISAMPLE_RESOLVE_BOX_BIT 0x0200
#define EGL_MULTISAMPLE_RESOLVE 0x3099 #define EGL_MULTISAMPLE_RESOLVE 0x3099
#define EGL_MULTISAMPLE_RESOLVE_DEFAULT 0x309A #define EGL_MULTISAMPLE_RESOLVE_DEFAULT 0x309A
#define EGL_MULTISAMPLE_RESOLVE_BOX 0x309B #define EGL_MULTISAMPLE_RESOLVE_BOX 0x309B
#define EGL_OPENGL_API 0x30A2 #define EGL_OPENGL_API 0x30A2
#define EGL_OPENGL_BIT 0x0008 #define EGL_OPENGL_BIT 0x0008
#define EGL_SWAP_BEHAVIOR_PRESERVED_BIT 0x0400 #define EGL_SWAP_BEHAVIOR_PRESERVED_BIT 0x0400
EGLAPI EGLContext EGLAPIENTRY eglGetCurrentContext (void); EGLAPI EGLContext EGLAPIENTRY eglGetCurrentContext (void);
#endif /* EGL_VERSION_1_4 */ #endif /* EGL_VERSION_1_4 */
#ifndef EGL_VERSION_1_5 #ifndef EGL_VERSION_1_5
#define EGL_VERSION_1_5 1 #define EGL_VERSION_1_5 1
typedef void *EGLSync; typedef void *EGLSync;
typedef intptr_t EGLAttrib; typedef intptr_t EGLAttrib;
typedef khronos_utime_nanoseconds_t EGLTime; typedef khronos_utime_nanoseconds_t EGLTime;
#define EGL_CONTEXT_MAJOR_VERSION 0x3098 #define EGL_CONTEXT_MAJOR_VERSION 0x3098
#define EGL_CONTEXT_MINOR_VERSION 0x30FB #define EGL_CONTEXT_MINOR_VERSION 0x30FB
#define EGL_CONTEXT_OPENGL_PROFILE_MASK 0x30FD #define EGL_CONTEXT_OPENGL_PROFILE_MASK 0x30FD
#define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY 0x31BD #define EGL_CONTEXT_OPENGL_RESET_NOTIFICATION_STRATEGY 0x31BD
#define EGL_NO_RESET_NOTIFICATION 0x31BE #define EGL_NO_RESET_NOTIFICATION 0x31BE
#define EGL_LOSE_CONTEXT_ON_RESET 0x31BF #define EGL_LOSE_CONTEXT_ON_RESET 0x31BF
#define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT 0x00000001 #define EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT 0x00000001
#define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT 0x00000002 #define EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT 0x00000002
#define EGL_CONTEXT_OPENGL_DEBUG 0x31B0 #define EGL_CONTEXT_OPENGL_DEBUG 0x31B0
#define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE 0x31B1 #define EGL_CONTEXT_OPENGL_FORWARD_COMPATIBLE 0x31B1
#define EGL_CONTEXT_OPENGL_ROBUST_ACCESS 0x31B2 #define EGL_CONTEXT_OPENGL_ROBUST_ACCESS 0x31B2
#define EGL_OPENGL_ES3_BIT 0x00000040 #define EGL_OPENGL_ES3_BIT 0x00000040
#define EGL_CL_EVENT_HANDLE 0x309C #define EGL_CL_EVENT_HANDLE 0x309C
#define EGL_SYNC_CL_EVENT 0x30FE #define EGL_SYNC_CL_EVENT 0x30FE
#define EGL_SYNC_CL_EVENT_COMPLETE 0x30FF #define EGL_SYNC_CL_EVENT_COMPLETE 0x30FF
#define EGL_SYNC_PRIOR_COMMANDS_COMPLETE 0x30F0 #define EGL_SYNC_PRIOR_COMMANDS_COMPLETE 0x30F0
#define EGL_SYNC_TYPE 0x30F7 #define EGL_SYNC_TYPE 0x30F7
#define EGL_SYNC_STATUS 0x30F1 #define EGL_SYNC_STATUS 0x30F1
#define EGL_SYNC_CONDITION 0x30F8 #define EGL_SYNC_CONDITION 0x30F8
#define EGL_SIGNALED 0x30F2 #define EGL_SIGNALED 0x30F2
#define EGL_UNSIGNALED 0x30F3 #define EGL_UNSIGNALED 0x30F3
#define EGL_SYNC_FLUSH_COMMANDS_BIT 0x0001 #define EGL_SYNC_FLUSH_COMMANDS_BIT 0x0001
#define EGL_FOREVER 0xFFFFFFFFFFFFFFFFull #define EGL_FOREVER 0xFFFFFFFFFFFFFFFFull
#define EGL_TIMEOUT_EXPIRED 0x30F5 #define EGL_TIMEOUT_EXPIRED 0x30F5
#define EGL_CONDITION_SATISFIED 0x30F6 #define EGL_CONDITION_SATISFIED 0x30F6
#define EGL_NO_SYNC ((EGLSync)0) #define EGL_NO_SYNC ((EGLSync)0)
#define EGL_SYNC_FENCE 0x30F9 #define EGL_SYNC_FENCE 0x30F9
#define EGL_GL_COLORSPACE 0x309D #define EGL_GL_COLORSPACE 0x309D
#define EGL_GL_COLORSPACE_SRGB 0x3089 #define EGL_GL_COLORSPACE_SRGB 0x3089
#define EGL_GL_COLORSPACE_LINEAR 0x308A #define EGL_GL_COLORSPACE_LINEAR 0x308A
#define EGL_GL_RENDERBUFFER 0x30B9 #define EGL_GL_RENDERBUFFER 0x30B9
#define EGL_GL_TEXTURE_2D 0x30B1 #define EGL_GL_TEXTURE_2D 0x30B1
#define EGL_GL_TEXTURE_LEVEL 0x30BC #define EGL_GL_TEXTURE_LEVEL 0x30BC
#define EGL_GL_TEXTURE_3D 0x30B2 #define EGL_GL_TEXTURE_3D 0x30B2
#define EGL_GL_TEXTURE_ZOFFSET 0x30BD #define EGL_GL_TEXTURE_ZOFFSET 0x30BD
#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x30B3 #define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X 0x30B3
#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x30B4 #define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X 0x30B4
#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x30B5 #define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y 0x30B5
#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x30B6 #define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y 0x30B6
#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x30B7 #define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z 0x30B7
#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x30B8 #define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z 0x30B8
EGLAPI EGLSync EGLAPIENTRY eglCreateSync (EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list); EGLAPI EGLSync EGLAPIENTRY eglCreateSync (EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list);
EGLAPI EGLBoolean EGLAPIENTRY eglDestroySync (EGLDisplay dpy, EGLSync sync); EGLAPI EGLBoolean EGLAPIENTRY eglDestroySync (EGLDisplay dpy, EGLSync sync);
EGLAPI EGLint EGLAPIENTRY eglClientWaitSync (EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout); EGLAPI EGLint EGLAPIENTRY eglClientWaitSync (EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout);
EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncAttrib (EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib *value); EGLAPI EGLBoolean EGLAPIENTRY eglGetSyncAttrib (EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib *value);
EGLAPI EGLDisplay EGLAPIENTRY eglGetPlatformDisplay (EGLenum platform, void *native_display, const EGLAttrib *attrib_list); EGLAPI EGLDisplay EGLAPIENTRY eglGetPlatformDisplay (EGLenum platform, void *native_display, const EGLAttrib *attrib_list);
EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformWindowSurface (EGLDisplay dpy, EGLConfig config, void *native_window, const EGLAttrib *attrib_list); EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformWindowSurface (EGLDisplay dpy, EGLConfig config, void *native_window, const EGLAttrib *attrib_list);
EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformPixmapSurface (EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLAttrib *attrib_list); EGLAPI EGLSurface EGLAPIENTRY eglCreatePlatformPixmapSurface (EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLAttrib *attrib_list);
EGLAPI EGLBoolean EGLAPIENTRY eglWaitSync (EGLDisplay dpy, EGLSync sync, EGLint flags); EGLAPI EGLBoolean EGLAPIENTRY eglWaitSync (EGLDisplay dpy, EGLSync sync, EGLint flags);
#endif /* EGL_VERSION_1_5 */ #endif /* EGL_VERSION_1_5 */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif #endif

1532
platform/winrt/include/EGL/eglext.h
View file

File diff suppressed because it is too large Load diff

262
platform/winrt/include/EGL/eglplatform.h
View file

@ -1,131 +1,131 @@
#ifndef __eglplatform_h_ #ifndef __eglplatform_h_
#define __eglplatform_h_ #define __eglplatform_h_
/* /*
** Copyright (c) 2007-2013 The Khronos Group Inc. ** Copyright (c) 2007-2013 The Khronos Group Inc.
** **
** Permission is hereby granted, free of charge, to any person obtaining a ** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the ** copy of this software and/or associated documentation files (the
** "Materials"), to deal in the Materials without restriction, including ** "Materials"), to deal in the Materials without restriction, including
** without limitation the rights to use, copy, modify, merge, publish, ** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Materials, and to ** distribute, sublicense, and/or sell copies of the Materials, and to
** permit persons to whom the Materials are furnished to do so, subject to ** permit persons to whom the Materials are furnished to do so, subject to
** the following conditions: ** the following conditions:
** **
** The above copyright notice and this permission notice shall be included ** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Materials. ** in all copies or substantial portions of the Materials.
** **
** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/ */
/* Platform-specific types and definitions for egl.h /* Platform-specific types and definitions for egl.h
* $Revision: 23432 $ on $Date: 2013-10-09 00:57:24 -0700 (Wed, 09 Oct 2013) $ * $Revision: 23432 $ on $Date: 2013-10-09 00:57:24 -0700 (Wed, 09 Oct 2013) $
* *
* Adopters may modify khrplatform.h and this file to suit their platform. * Adopters may modify khrplatform.h and this file to suit their platform.
* You are encouraged to submit all modifications to the Khronos group so that * You are encouraged to submit all modifications to the Khronos group so that
* they can be included in future versions of this file. Please submit changes * they can be included in future versions of this file. Please submit changes
* by sending them to the public Khronos Bugzilla (http://khronos.org/bugzilla) * by sending them to the public Khronos Bugzilla (http://khronos.org/bugzilla)
* by filing a bug against product "EGL" component "Registry". * by filing a bug against product "EGL" component "Registry".
*/ */
#include <KHR/khrplatform.h> #include <KHR/khrplatform.h>
/* Macros used in EGL function prototype declarations. /* Macros used in EGL function prototype declarations.
* *
* EGL functions should be prototyped as: * EGL functions should be prototyped as:
* *
* EGLAPI return-type EGLAPIENTRY eglFunction(arguments); * EGLAPI return-type EGLAPIENTRY eglFunction(arguments);
* typedef return-type (EXPAPIENTRYP PFNEGLFUNCTIONPROC) (arguments); * typedef return-type (EXPAPIENTRYP PFNEGLFUNCTIONPROC) (arguments);
* *
* KHRONOS_APICALL and KHRONOS_APIENTRY are defined in KHR/khrplatform.h * KHRONOS_APICALL and KHRONOS_APIENTRY are defined in KHR/khrplatform.h
*/ */
#ifndef EGLAPI #ifndef EGLAPI
#define EGLAPI KHRONOS_APICALL #define EGLAPI KHRONOS_APICALL
#endif #endif
#ifndef EGLAPIENTRY #ifndef EGLAPIENTRY
#define EGLAPIENTRY KHRONOS_APIENTRY #define EGLAPIENTRY KHRONOS_APIENTRY
#endif #endif
#define EGLAPIENTRYP EGLAPIENTRY* #define EGLAPIENTRYP EGLAPIENTRY*
/* The types NativeDisplayType, NativeWindowType, and NativePixmapType /* The types NativeDisplayType, NativeWindowType, and NativePixmapType
* are aliases of window-system-dependent types, such as X Display * or * are aliases of window-system-dependent types, such as X Display * or
* Windows Device Context. They must be defined in platform-specific * Windows Device Context. They must be defined in platform-specific
* code below. The EGL-prefixed versions of Native*Type are the same * code below. The EGL-prefixed versions of Native*Type are the same
* types, renamed in EGL 1.3 so all types in the API start with "EGL". * types, renamed in EGL 1.3 so all types in the API start with "EGL".
* *
* Khronos STRONGLY RECOMMENDS that you use the default definitions * Khronos STRONGLY RECOMMENDS that you use the default definitions
* provided below, since these changes affect both binary and source * provided below, since these changes affect both binary and source
* portability of applications using EGL running on different EGL * portability of applications using EGL running on different EGL
* implementations. * implementations.
*/ */
#if defined(_WIN32) || defined(__VC32__) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) /* Win32 and WinCE */ #if defined(_WIN32) || defined(__VC32__) && !defined(__CYGWIN__) && !defined(__SCITECH_SNAP__) /* Win32 and WinCE */
#ifndef WIN32_LEAN_AND_MEAN #ifndef WIN32_LEAN_AND_MEAN
#define WIN32_LEAN_AND_MEAN 1 #define WIN32_LEAN_AND_MEAN 1
#endif #endif
#include <windows.h> #include <windows.h>
typedef HDC EGLNativeDisplayType; typedef HDC EGLNativeDisplayType;
typedef HBITMAP EGLNativePixmapType; typedef HBITMAP EGLNativePixmapType;
#if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_PC_APP || WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP) /* Windows Store */ #if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_PC_APP || WINAPI_FAMILY == WINAPI_FAMILY_PHONE_APP) /* Windows Store */
#include <inspectable.h> #include <inspectable.h>
typedef IInspectable* EGLNativeWindowType; typedef IInspectable* EGLNativeWindowType;
#else #else
typedef HWND EGLNativeWindowType; typedef HWND EGLNativeWindowType;
#endif #endif
#elif defined(__WINSCW__) || defined(__SYMBIAN32__) /* Symbian */ #elif defined(__WINSCW__) || defined(__SYMBIAN32__) /* Symbian */
typedef int EGLNativeDisplayType; typedef int EGLNativeDisplayType;
typedef void *EGLNativeWindowType; typedef void *EGLNativeWindowType;
typedef void *EGLNativePixmapType; typedef void *EGLNativePixmapType;
#elif defined(__ANDROID__) || defined(ANDROID) #elif defined(__ANDROID__) || defined(ANDROID)
#include <android/native_window.h> #include <android/native_window.h>
struct egl_native_pixmap_t; struct egl_native_pixmap_t;
typedef struct ANativeWindow* EGLNativeWindowType; typedef struct ANativeWindow* EGLNativeWindowType;
typedef struct egl_native_pixmap_t* EGLNativePixmapType; typedef struct egl_native_pixmap_t* EGLNativePixmapType;
typedef void* EGLNativeDisplayType; typedef void* EGLNativeDisplayType;
#elif defined(__unix__) #elif defined(__unix__)
/* X11 (tentative) */ /* X11 (tentative) */
#include <X11/Xlib.h> #include <X11/Xlib.h>
#include <X11/Xutil.h> #include <X11/Xutil.h>
typedef Display *EGLNativeDisplayType; typedef Display *EGLNativeDisplayType;
typedef Pixmap EGLNativePixmapType; typedef Pixmap EGLNativePixmapType;
typedef Window EGLNativeWindowType; typedef Window EGLNativeWindowType;
#else #else
#error "Platform not recognized" #error "Platform not recognized"
#endif #endif
/* EGL 1.2 types, renamed for consistency in EGL 1.3 */ /* EGL 1.2 types, renamed for consistency in EGL 1.3 */
typedef EGLNativeDisplayType NativeDisplayType; typedef EGLNativeDisplayType NativeDisplayType;
typedef EGLNativePixmapType NativePixmapType; typedef EGLNativePixmapType NativePixmapType;
typedef EGLNativeWindowType NativeWindowType; typedef EGLNativeWindowType NativeWindowType;
/* Define EGLint. This must be a signed integral type large enough to contain /* Define EGLint. This must be a signed integral type large enough to contain
* all legal attribute names and values passed into and out of EGL, whether * all legal attribute names and values passed into and out of EGL, whether
* their type is boolean, bitmask, enumerant (symbolic constant), integer, * their type is boolean, bitmask, enumerant (symbolic constant), integer,
* handle, or other. While in general a 32-bit integer will suffice, if * handle, or other. While in general a 32-bit integer will suffice, if
* handles are 64 bit types, then EGLint should be defined as a signed 64-bit * handles are 64 bit types, then EGLint should be defined as a signed 64-bit
* integer type. * integer type.
*/ */
typedef khronos_int32_t EGLint; typedef khronos_int32_t EGLint;
#endif /* __eglplatform_h */ #endif /* __eglplatform_h */

1240
platform/winrt/include/GLES2/gl2.h
View file

File diff suppressed because it is too large Load diff

4026
platform/winrt/include/GLES2/gl2ext.h
View file

File diff suppressed because it is too large Load diff

60
platform/winrt/include/GLES2/gl2platform.h
View file

@ -1,30 +1,30 @@
#ifndef __gl2platform_h_ #ifndef __gl2platform_h_
#define __gl2platform_h_ #define __gl2platform_h_
/* $Revision: 10602 $ on $Date:: 2010-03-04 22:35:34 -0800 #$ */ /* $Revision: 10602 $ on $Date:: 2010-03-04 22:35:34 -0800 #$ */
/* /*
* This document is licensed under the SGI Free Software B License Version * This document is licensed under the SGI Free Software B License Version
* 2.0. For details, see http://oss.sgi.com/projects/FreeB/ . * 2.0. For details, see http://oss.sgi.com/projects/FreeB/ .
*/ */
/* Platform-specific types and definitions for OpenGL ES 2.X gl2.h /* Platform-specific types and definitions for OpenGL ES 2.X gl2.h
* *
* Adopters may modify khrplatform.h and this file to suit their platform. * Adopters may modify khrplatform.h and this file to suit their platform.
* You are encouraged to submit all modifications to the Khronos group so that * You are encouraged to submit all modifications to the Khronos group so that
* they can be included in future versions of this file. Please submit changes * they can be included in future versions of this file. Please submit changes
* by sending them to the public Khronos Bugzilla (http://khronos.org/bugzilla) * by sending them to the public Khronos Bugzilla (http://khronos.org/bugzilla)
* by filing a bug against product "OpenGL-ES" component "Registry". * by filing a bug against product "OpenGL-ES" component "Registry".
*/ */
#include <KHR/khrplatform.h> #include <KHR/khrplatform.h>
#ifndef GL_APICALL #ifndef GL_APICALL
#define GL_APICALL KHRONOS_APICALL #define GL_APICALL KHRONOS_APICALL
#endif #endif
#ifndef GL_APIENTRY #ifndef GL_APIENTRY
#define GL_APIENTRY KHRONOS_APIENTRY #define GL_APIENTRY KHRONOS_APIENTRY
#endif #endif
#endif /* __gl2platform_h_ */ #endif /* __gl2platform_h_ */

2122
platform/winrt/include/GLES3/gl3.h
View file

File diff suppressed because it is too large Load diff

48
platform/winrt/include/GLES3/gl3ext.h
View file

@ -1,24 +1,24 @@
#ifndef __gl3ext_h_ #ifndef __gl3ext_h_
#define __gl3ext_h_ #define __gl3ext_h_
/* $Revision: 17809 $ on $Date:: 2012-05-14 08:03:36 -0700 #$ */ /* $Revision: 17809 $ on $Date:: 2012-05-14 08:03:36 -0700 #$ */
/* /*
* This document is licensed under the SGI Free Software B License Version * This document is licensed under the SGI Free Software B License Version
* 2.0. For details, see http://oss.sgi.com/projects/FreeB/ . * 2.0. For details, see http://oss.sgi.com/projects/FreeB/ .
*/ */
/* OpenGL ES 3 Extensions /* OpenGL ES 3 Extensions
* *
* After an OES extension's interactions with OpenGl ES 3.0 have been documented, * After an OES extension's interactions with OpenGl ES 3.0 have been documented,
* its tokens and function definitions should be added to this file in a manner * its tokens and function definitions should be added to this file in a manner
* that does not conflict with gl2ext.h or gl3.h. * that does not conflict with gl2ext.h or gl3.h.
* *
* Tokens and function definitions for extensions that have become standard * Tokens and function definitions for extensions that have become standard
* features in OpenGL ES 3.0 will not be added to this file. * features in OpenGL ES 3.0 will not be added to this file.
* *
* Applications using OpenGL-ES-2-only extensions should include gl2ext.h * Applications using OpenGL-ES-2-only extensions should include gl2ext.h
*/ */
#endif /* __gl3ext_h_ */ #endif /* __gl3ext_h_ */

60
platform/winrt/include/GLES3/gl3platform.h
View file

@ -1,30 +1,30 @@
#ifndef __gl3platform_h_ #ifndef __gl3platform_h_
#define __gl3platform_h_ #define __gl3platform_h_
/* $Revision: 18437 $ on $Date:: 2012-07-08 23:31:39 -0700 #$ */ /* $Revision: 18437 $ on $Date:: 2012-07-08 23:31:39 -0700 #$ */
/* /*
* This document is licensed under the SGI Free Software B License Version * This document is licensed under the SGI Free Software B License Version
* 2.0. For details, see http://oss.sgi.com/projects/FreeB/ . * 2.0. For details, see http://oss.sgi.com/projects/FreeB/ .
*/ */
/* Platform-specific types and definitions for OpenGL ES 3.X gl3.h /* Platform-specific types and definitions for OpenGL ES 3.X gl3.h
* *
* Adopters may modify khrplatform.h and this file to suit their platform. * Adopters may modify khrplatform.h and this file to suit their platform.
* You are encouraged to submit all modifications to the Khronos group so that * You are encouraged to submit all modifications to the Khronos group so that
* they can be included in future versions of this file. Please submit changes * they can be included in future versions of this file. Please submit changes
* by sending them to the public Khronos Bugzilla (http://khronos.org/bugzilla) * by sending them to the public Khronos Bugzilla (http://khronos.org/bugzilla)
* by filing a bug against product "OpenGL-ES" component "Registry". * by filing a bug against product "OpenGL-ES" component "Registry".
*/ */
#include <KHR/khrplatform.h> #include <KHR/khrplatform.h>
#ifndef GL_APICALL #ifndef GL_APICALL
#define GL_APICALL KHRONOS_APICALL #define GL_APICALL KHRONOS_APICALL
#endif #endif
#ifndef GL_APIENTRY #ifndef GL_APIENTRY
#define GL_APIENTRY KHRONOS_APIENTRY #define GL_APIENTRY KHRONOS_APIENTRY
#endif #endif
#endif /* __gl3platform_h_ */ #endif /* __gl3platform_h_ */

822
platform/winrt/include/GLSLANG/ShaderLang.h
View file

@ -1,411 +1,411 @@
// //
// Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved. // Copyright (c) 2002-2013 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be // Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. // found in the LICENSE file.
// //
#ifndef _COMPILER_INTERFACE_INCLUDED_ #ifndef _COMPILER_INTERFACE_INCLUDED_
#define _COMPILER_INTERFACE_INCLUDED_ #define _COMPILER_INTERFACE_INCLUDED_
#if defined(COMPONENT_BUILD) && !defined(ANGLE_TRANSLATOR_STATIC) #if defined(COMPONENT_BUILD) && !defined(ANGLE_TRANSLATOR_STATIC)
#if defined(_WIN32) || defined(_WIN64) #if defined(_WIN32) || defined(_WIN64)
#if defined(ANGLE_TRANSLATOR_IMPLEMENTATION) #if defined(ANGLE_TRANSLATOR_IMPLEMENTATION)
#define COMPILER_EXPORT __declspec(dllexport) #define COMPILER_EXPORT __declspec(dllexport)
#else #else
#define COMPILER_EXPORT __declspec(dllimport) #define COMPILER_EXPORT __declspec(dllimport)
#endif // defined(ANGLE_TRANSLATOR_IMPLEMENTATION) #endif // defined(ANGLE_TRANSLATOR_IMPLEMENTATION)
#else // defined(_WIN32) || defined(_WIN64) #else // defined(_WIN32) || defined(_WIN64)
#define COMPILER_EXPORT __attribute__((visibility("default"))) #define COMPILER_EXPORT __attribute__((visibility("default")))
#endif #endif
#else // defined(COMPONENT_BUILD) && !defined(ANGLE_TRANSLATOR_STATIC) #else // defined(COMPONENT_BUILD) && !defined(ANGLE_TRANSLATOR_STATIC)
#define COMPILER_EXPORT #define COMPILER_EXPORT
#endif #endif
#include <stddef.h> #include <stddef.h>
#include "KHR/khrplatform.h" #include "KHR/khrplatform.h"
#include <map> #include <map>
#include <string> #include <string>
#include <vector> #include <vector>
// //
// This is the platform independent interface between an OGL driver // This is the platform independent interface between an OGL driver
// and the shading language compiler. // and the shading language compiler.
// //
namespace sh namespace sh
{ {
// GLenum alias // GLenum alias
typedef unsigned int GLenum; typedef unsigned int GLenum;
} }
// Must be included after GLenum proxy typedef // Must be included after GLenum proxy typedef
// Note: make sure to increment ANGLE_SH_VERSION when changing ShaderVars.h // Note: make sure to increment ANGLE_SH_VERSION when changing ShaderVars.h
#include "ShaderVars.h" #include "ShaderVars.h"
// Version number for shader translation API. // Version number for shader translation API.
// It is incremented every time the API changes. // It is incremented every time the API changes.
#define ANGLE_SH_VERSION 132 #define ANGLE_SH_VERSION 132
typedef enum { typedef enum {
SH_GLES2_SPEC = 0x8B40, SH_GLES2_SPEC = 0x8B40,
SH_WEBGL_SPEC = 0x8B41, SH_WEBGL_SPEC = 0x8B41,
SH_GLES3_SPEC = 0x8B86, SH_GLES3_SPEC = 0x8B86,
SH_WEBGL2_SPEC = 0x8B87, SH_WEBGL2_SPEC = 0x8B87,
// The CSS Shaders spec is a subset of the WebGL spec. // The CSS Shaders spec is a subset of the WebGL spec.
// //
// In both CSS vertex and fragment shaders, ANGLE: // In both CSS vertex and fragment shaders, ANGLE:
// (1) Reserves the "css_" prefix. // (1) Reserves the "css_" prefix.
// (2) Renames the main function to css_main. // (2) Renames the main function to css_main.
// (3) Disables the gl_MaxDrawBuffers built-in. // (3) Disables the gl_MaxDrawBuffers built-in.
// //
// In CSS fragment shaders, ANGLE: // In CSS fragment shaders, ANGLE:
// (1) Disables the gl_FragColor built-in. // (1) Disables the gl_FragColor built-in.
// (2) Disables the gl_FragData built-in. // (2) Disables the gl_FragData built-in.
// (3) Enables the css_MixColor built-in. // (3) Enables the css_MixColor built-in.
// (4) Enables the css_ColorMatrix built-in. // (4) Enables the css_ColorMatrix built-in.
// //
// After passing a CSS shader through ANGLE, the browser is expected to append // After passing a CSS shader through ANGLE, the browser is expected to append
// a new main function to it. // a new main function to it.
// This new main function will call the css_main function. // This new main function will call the css_main function.
// It may also perform additional operations like varying assignment, texture // It may also perform additional operations like varying assignment, texture
// access, and gl_FragColor assignment in order to implement the CSS Shaders // access, and gl_FragColor assignment in order to implement the CSS Shaders
// blend modes. // blend modes.
// //
SH_CSS_SHADERS_SPEC = 0x8B42 SH_CSS_SHADERS_SPEC = 0x8B42
} ShShaderSpec; } ShShaderSpec;
typedef enum { typedef enum {
SH_ESSL_OUTPUT = 0x8B45, SH_ESSL_OUTPUT = 0x8B45,
SH_GLSL_OUTPUT = 0x8B46, SH_GLSL_OUTPUT = 0x8B46,
SH_HLSL_OUTPUT = 0x8B47, SH_HLSL_OUTPUT = 0x8B47,
SH_HLSL9_OUTPUT = 0x8B47, SH_HLSL9_OUTPUT = 0x8B47,
SH_HLSL11_OUTPUT = 0x8B48 SH_HLSL11_OUTPUT = 0x8B48
} ShShaderOutput; } ShShaderOutput;
// Compile options. // Compile options.
typedef enum { typedef enum {
SH_VALIDATE = 0, SH_VALIDATE = 0,
SH_VALIDATE_LOOP_INDEXING = 0x0001, SH_VALIDATE_LOOP_INDEXING = 0x0001,
SH_INTERMEDIATE_TREE = 0x0002, SH_INTERMEDIATE_TREE = 0x0002,
SH_OBJECT_CODE = 0x0004, SH_OBJECT_CODE = 0x0004,
SH_VARIABLES = 0x0008, SH_VARIABLES = 0x0008,
SH_LINE_DIRECTIVES = 0x0010, SH_LINE_DIRECTIVES = 0x0010,
SH_SOURCE_PATH = 0x0020, SH_SOURCE_PATH = 0x0020,
SH_UNROLL_FOR_LOOP_WITH_INTEGER_INDEX = 0x0040, SH_UNROLL_FOR_LOOP_WITH_INTEGER_INDEX = 0x0040,
// If a sampler array index happens to be a loop index, // If a sampler array index happens to be a loop index,
// 1) if its type is integer, unroll the loop. // 1) if its type is integer, unroll the loop.
// 2) if its type is float, fail the shader compile. // 2) if its type is float, fail the shader compile.
// This is to work around a mac driver bug. // This is to work around a mac driver bug.
SH_UNROLL_FOR_LOOP_WITH_SAMPLER_ARRAY_INDEX = 0x0080, SH_UNROLL_FOR_LOOP_WITH_SAMPLER_ARRAY_INDEX = 0x0080,
// This is needed only as a workaround for certain OpenGL driver bugs. // This is needed only as a workaround for certain OpenGL driver bugs.
SH_EMULATE_BUILT_IN_FUNCTIONS = 0x0100, SH_EMULATE_BUILT_IN_FUNCTIONS = 0x0100,
// This is an experimental flag to enforce restrictions that aim to prevent // This is an experimental flag to enforce restrictions that aim to prevent
// timing attacks. // timing attacks.
// It generates compilation errors for shaders that could expose sensitive // It generates compilation errors for shaders that could expose sensitive
// texture information via the timing channel. // texture information via the timing channel.
// To use this flag, you must compile the shader under the WebGL spec // To use this flag, you must compile the shader under the WebGL spec
// (using the SH_WEBGL_SPEC flag). // (using the SH_WEBGL_SPEC flag).
SH_TIMING_RESTRICTIONS = 0x0200, SH_TIMING_RESTRICTIONS = 0x0200,
// This flag prints the dependency graph that is used to enforce timing // This flag prints the dependency graph that is used to enforce timing
// restrictions on fragment shaders. // restrictions on fragment shaders.
// This flag only has an effect if all of the following are true: // This flag only has an effect if all of the following are true:
// - The shader spec is SH_WEBGL_SPEC. // - The shader spec is SH_WEBGL_SPEC.
// - The compile options contain the SH_TIMING_RESTRICTIONS flag. // - The compile options contain the SH_TIMING_RESTRICTIONS flag.
// - The shader type is GL_FRAGMENT_SHADER. // - The shader type is GL_FRAGMENT_SHADER.
SH_DEPENDENCY_GRAPH = 0x0400, SH_DEPENDENCY_GRAPH = 0x0400,
// Enforce the GLSL 1.017 Appendix A section 7 packing restrictions. // Enforce the GLSL 1.017 Appendix A section 7 packing restrictions.
// This flag only enforces (and can only enforce) the packing // This flag only enforces (and can only enforce) the packing
// restrictions for uniform variables in both vertex and fragment // restrictions for uniform variables in both vertex and fragment
// shaders. ShCheckVariablesWithinPackingLimits() lets embedders // shaders. ShCheckVariablesWithinPackingLimits() lets embedders
// enforce the packing restrictions for varying variables during // enforce the packing restrictions for varying variables during
// program link time. // program link time.
SH_ENFORCE_PACKING_RESTRICTIONS = 0x0800, SH_ENFORCE_PACKING_RESTRICTIONS = 0x0800,
// This flag ensures all indirect (expression-based) array indexing // This flag ensures all indirect (expression-based) array indexing
// is clamped to the bounds of the array. This ensures, for example, // is clamped to the bounds of the array. This ensures, for example,
// that you cannot read off the end of a uniform, whether an array // that you cannot read off the end of a uniform, whether an array
// vec234, or mat234 type. The ShArrayIndexClampingStrategy enum, // vec234, or mat234 type. The ShArrayIndexClampingStrategy enum,
// specified in the ShBuiltInResources when constructing the // specified in the ShBuiltInResources when constructing the
// compiler, selects the strategy for the clamping implementation. // compiler, selects the strategy for the clamping implementation.
SH_CLAMP_INDIRECT_ARRAY_BOUNDS = 0x1000, SH_CLAMP_INDIRECT_ARRAY_BOUNDS = 0x1000,
// This flag limits the complexity of an expression. // This flag limits the complexity of an expression.
SH_LIMIT_EXPRESSION_COMPLEXITY = 0x2000, SH_LIMIT_EXPRESSION_COMPLEXITY = 0x2000,
// This flag limits the depth of the call stack. // This flag limits the depth of the call stack.
SH_LIMIT_CALL_STACK_DEPTH = 0x4000, SH_LIMIT_CALL_STACK_DEPTH = 0x4000,
// This flag initializes gl_Position to vec4(0,0,0,0) at the // This flag initializes gl_Position to vec4(0,0,0,0) at the
// beginning of the vertex shader's main(), and has no effect in the // beginning of the vertex shader's main(), and has no effect in the
// fragment shader. It is intended as a workaround for drivers which // fragment shader. It is intended as a workaround for drivers which
// incorrectly fail to link programs if gl_Position is not written. // incorrectly fail to link programs if gl_Position is not written.
SH_INIT_GL_POSITION = 0x8000, SH_INIT_GL_POSITION = 0x8000,
// This flag replaces // This flag replaces
// "a && b" with "a ? b : false", // "a && b" with "a ? b : false",
// "a || b" with "a ? true : b". // "a || b" with "a ? true : b".
// This is to work around a MacOSX driver bug that |b| is executed // This is to work around a MacOSX driver bug that |b| is executed
// independent of |a|'s value. // independent of |a|'s value.
SH_UNFOLD_SHORT_CIRCUIT = 0x10000, SH_UNFOLD_SHORT_CIRCUIT = 0x10000,
// This flag initializes varyings without static use in vertex shader // This flag initializes varyings without static use in vertex shader
// at the beginning of main(), and has no effects in the fragment shader. // at the beginning of main(), and has no effects in the fragment shader.
// It is intended as a workaround for drivers which incorrectly optimize // It is intended as a workaround for drivers which incorrectly optimize
// out such varyings and cause a link failure. // out such varyings and cause a link failure.
SH_INIT_VARYINGS_WITHOUT_STATIC_USE = 0x20000, SH_INIT_VARYINGS_WITHOUT_STATIC_USE = 0x20000,
// This flag scalarizes vec/ivec/bvec/mat constructor args. // This flag scalarizes vec/ivec/bvec/mat constructor args.
// It is intended as a workaround for Linux/Mac driver bugs. // It is intended as a workaround for Linux/Mac driver bugs.
SH_SCALARIZE_VEC_AND_MAT_CONSTRUCTOR_ARGS = 0x40000, SH_SCALARIZE_VEC_AND_MAT_CONSTRUCTOR_ARGS = 0x40000,
// This flag overwrites a struct name with a unique prefix. // This flag overwrites a struct name with a unique prefix.
// It is intended as a workaround for drivers that do not handle // It is intended as a workaround for drivers that do not handle
// struct scopes correctly, including all Mac drivers and Linux AMD. // struct scopes correctly, including all Mac drivers and Linux AMD.
SH_REGENERATE_STRUCT_NAMES = 0x80000, SH_REGENERATE_STRUCT_NAMES = 0x80000,
} ShCompileOptions; } ShCompileOptions;
// Defines alternate strategies for implementing array index clamping. // Defines alternate strategies for implementing array index clamping.
typedef enum { typedef enum {
// Use the clamp intrinsic for array index clamping. // Use the clamp intrinsic for array index clamping.
SH_CLAMP_WITH_CLAMP_INTRINSIC = 1, SH_CLAMP_WITH_CLAMP_INTRINSIC = 1,
// Use a user-defined function for array index clamping. // Use a user-defined function for array index clamping.
SH_CLAMP_WITH_USER_DEFINED_INT_CLAMP_FUNCTION SH_CLAMP_WITH_USER_DEFINED_INT_CLAMP_FUNCTION
} ShArrayIndexClampingStrategy; } ShArrayIndexClampingStrategy;
// //
// Driver must call this first, once, before doing any other // Driver must call this first, once, before doing any other
// compiler operations. // compiler operations.
// If the function succeeds, the return value is true, else false. // If the function succeeds, the return value is true, else false.
// //
COMPILER_EXPORT bool ShInitialize(); COMPILER_EXPORT bool ShInitialize();
// //
// Driver should call this at shutdown. // Driver should call this at shutdown.
// If the function succeeds, the return value is true, else false. // If the function succeeds, the return value is true, else false.
// //
COMPILER_EXPORT bool ShFinalize(); COMPILER_EXPORT bool ShFinalize();
// The 64 bits hash function. The first parameter is the input string; the // The 64 bits hash function. The first parameter is the input string; the
// second parameter is the string length. // second parameter is the string length.
typedef khronos_uint64_t (*ShHashFunction64)(const char*, size_t); typedef khronos_uint64_t (*ShHashFunction64)(const char*, size_t);
// //
// Implementation dependent built-in resources (constants and extensions). // Implementation dependent built-in resources (constants and extensions).
// The names for these resources has been obtained by stripping gl_/GL_. // The names for these resources has been obtained by stripping gl_/GL_.
// //
typedef struct typedef struct
{ {
// Constants. // Constants.
int MaxVertexAttribs; int MaxVertexAttribs;
int MaxVertexUniformVectors; int MaxVertexUniformVectors;
int MaxVaryingVectors; int MaxVaryingVectors;
int MaxVertexTextureImageUnits; int MaxVertexTextureImageUnits;
int MaxCombinedTextureImageUnits; int MaxCombinedTextureImageUnits;
int MaxTextureImageUnits; int MaxTextureImageUnits;
int MaxFragmentUniformVectors; int MaxFragmentUniformVectors;
int MaxDrawBuffers; int MaxDrawBuffers;
// Extensions. // Extensions.
// Set to 1 to enable the extension, else 0. // Set to 1 to enable the extension, else 0.
int OES_standard_derivatives; int OES_standard_derivatives;
int OES_EGL_image_external; int OES_EGL_image_external;
int ARB_texture_rectangle; int ARB_texture_rectangle;
int EXT_draw_buffers; int EXT_draw_buffers;
int EXT_frag_depth; int EXT_frag_depth;
int EXT_shader_texture_lod; int EXT_shader_texture_lod;
// Set to 1 to enable replacing GL_EXT_draw_buffers #extension directives // Set to 1 to enable replacing GL_EXT_draw_buffers #extension directives
// with GL_NV_draw_buffers in ESSL output. This flag can be used to emulate // with GL_NV_draw_buffers in ESSL output. This flag can be used to emulate
// EXT_draw_buffers by using it in combination with GLES3.0 glDrawBuffers // EXT_draw_buffers by using it in combination with GLES3.0 glDrawBuffers
// function. This applies to Tegra K1 devices. // function. This applies to Tegra K1 devices.
int NV_draw_buffers; int NV_draw_buffers;
// Set to 1 if highp precision is supported in the fragment language. // Set to 1 if highp precision is supported in the fragment language.
// Default is 0. // Default is 0.
int FragmentPrecisionHigh; int FragmentPrecisionHigh;
// GLSL ES 3.0 constants. // GLSL ES 3.0 constants.
int MaxVertexOutputVectors; int MaxVertexOutputVectors;
int MaxFragmentInputVectors; int MaxFragmentInputVectors;
int MinProgramTexelOffset; int MinProgramTexelOffset;
int MaxProgramTexelOffset; int MaxProgramTexelOffset;
// Name Hashing. // Name Hashing.
// Set a 64 bit hash function to enable user-defined name hashing. // Set a 64 bit hash function to enable user-defined name hashing.
// Default is NULL. // Default is NULL.
ShHashFunction64 HashFunction; ShHashFunction64 HashFunction;
// Selects a strategy to use when implementing array index clamping. // Selects a strategy to use when implementing array index clamping.
// Default is SH_CLAMP_WITH_CLAMP_INTRINSIC. // Default is SH_CLAMP_WITH_CLAMP_INTRINSIC.
ShArrayIndexClampingStrategy ArrayIndexClampingStrategy; ShArrayIndexClampingStrategy ArrayIndexClampingStrategy;
// The maximum complexity an expression can be. // The maximum complexity an expression can be.
int MaxExpressionComplexity; int MaxExpressionComplexity;
// The maximum depth a call stack can be. // The maximum depth a call stack can be.
int MaxCallStackDepth; int MaxCallStackDepth;
} ShBuiltInResources; } ShBuiltInResources;
// //
// Initialize built-in resources with minimum expected values. // Initialize built-in resources with minimum expected values.
// Parameters: // Parameters:
// resources: The object to initialize. Will be comparable with memcmp. // resources: The object to initialize. Will be comparable with memcmp.
// //
COMPILER_EXPORT void ShInitBuiltInResources(ShBuiltInResources *resources); COMPILER_EXPORT void ShInitBuiltInResources(ShBuiltInResources *resources);
// //
// ShHandle held by but opaque to the driver. It is allocated, // ShHandle held by but opaque to the driver. It is allocated,
// managed, and de-allocated by the compiler. Its contents // managed, and de-allocated by the compiler. Its contents
// are defined by and used by the compiler. // are defined by and used by the compiler.
// //
// If handle creation fails, 0 will be returned. // If handle creation fails, 0 will be returned.
// //
typedef void *ShHandle; typedef void *ShHandle;
// //
// Returns the a concatenated list of the items in ShBuiltInResources as a // Returns the a concatenated list of the items in ShBuiltInResources as a
// null-terminated string. // null-terminated string.
// This function must be updated whenever ShBuiltInResources is changed. // This function must be updated whenever ShBuiltInResources is changed.
// Parameters: // Parameters:
// handle: Specifies the handle of the compiler to be used. // handle: Specifies the handle of the compiler to be used.
COMPILER_EXPORT const std::string &ShGetBuiltInResourcesString(const ShHandle handle); COMPILER_EXPORT const std::string &ShGetBuiltInResourcesString(const ShHandle handle);
// //
// Driver calls these to create and destroy compiler objects. // Driver calls these to create and destroy compiler objects.
// //
// Returns the handle of constructed compiler, null if the requested compiler is // Returns the handle of constructed compiler, null if the requested compiler is
// not supported. // not supported.
// Parameters: // Parameters:
// type: Specifies the type of shader - GL_FRAGMENT_SHADER or GL_VERTEX_SHADER. // type: Specifies the type of shader - GL_FRAGMENT_SHADER or GL_VERTEX_SHADER.
// spec: Specifies the language spec the compiler must conform to - // spec: Specifies the language spec the compiler must conform to -
// SH_GLES2_SPEC or SH_WEBGL_SPEC. // SH_GLES2_SPEC or SH_WEBGL_SPEC.
// output: Specifies the output code type - SH_ESSL_OUTPUT, SH_GLSL_OUTPUT, // output: Specifies the output code type - SH_ESSL_OUTPUT, SH_GLSL_OUTPUT,
// SH_HLSL9_OUTPUT or SH_HLSL11_OUTPUT. // SH_HLSL9_OUTPUT or SH_HLSL11_OUTPUT.
// resources: Specifies the built-in resources. // resources: Specifies the built-in resources.
COMPILER_EXPORT ShHandle ShConstructCompiler( COMPILER_EXPORT ShHandle ShConstructCompiler(
sh::GLenum type, sh::GLenum type,
ShShaderSpec spec, ShShaderSpec spec,
ShShaderOutput output, ShShaderOutput output,
const ShBuiltInResources *resources); const ShBuiltInResources *resources);
COMPILER_EXPORT void ShDestruct(ShHandle handle); COMPILER_EXPORT void ShDestruct(ShHandle handle);
// //
// Compiles the given shader source. // Compiles the given shader source.
// If the function succeeds, the return value is true, else false. // If the function succeeds, the return value is true, else false.
// Parameters: // Parameters:
// handle: Specifies the handle of compiler to be used. // handle: Specifies the handle of compiler to be used.
// shaderStrings: Specifies an array of pointers to null-terminated strings // shaderStrings: Specifies an array of pointers to null-terminated strings
// containing the shader source code. // containing the shader source code.
// numStrings: Specifies the number of elements in shaderStrings array. // numStrings: Specifies the number of elements in shaderStrings array.
// compileOptions: A mask containing the following parameters: // compileOptions: A mask containing the following parameters:
// SH_VALIDATE: Validates shader to ensure that it conforms to the spec // SH_VALIDATE: Validates shader to ensure that it conforms to the spec
// specified during compiler construction. // specified during compiler construction.
// SH_VALIDATE_LOOP_INDEXING: Validates loop and indexing in the shader to // SH_VALIDATE_LOOP_INDEXING: Validates loop and indexing in the shader to
// ensure that they do not exceed the minimum // ensure that they do not exceed the minimum
// functionality mandated in GLSL 1.0 spec, // functionality mandated in GLSL 1.0 spec,
// Appendix A, Section 4 and 5. // Appendix A, Section 4 and 5.
// There is no need to specify this parameter when // There is no need to specify this parameter when
// compiling for WebGL - it is implied. // compiling for WebGL - it is implied.
// SH_INTERMEDIATE_TREE: Writes intermediate tree to info log. // SH_INTERMEDIATE_TREE: Writes intermediate tree to info log.
// Can be queried by calling ShGetInfoLog(). // Can be queried by calling ShGetInfoLog().
// SH_OBJECT_CODE: Translates intermediate tree to glsl or hlsl shader. // SH_OBJECT_CODE: Translates intermediate tree to glsl or hlsl shader.
// Can be queried by calling ShGetObjectCode(). // Can be queried by calling ShGetObjectCode().
// SH_VARIABLES: Extracts attributes, uniforms, and varyings. // SH_VARIABLES: Extracts attributes, uniforms, and varyings.
// Can be queried by calling ShGetVariableInfo(). // Can be queried by calling ShGetVariableInfo().
// //
COMPILER_EXPORT bool ShCompile( COMPILER_EXPORT bool ShCompile(
const ShHandle handle, const ShHandle handle,
const char * const shaderStrings[], const char * const shaderStrings[],
size_t numStrings, size_t numStrings,
int compileOptions); int compileOptions);
// Return the version of the shader language. // Return the version of the shader language.
COMPILER_EXPORT int ShGetShaderVersion(const ShHandle handle); COMPILER_EXPORT int ShGetShaderVersion(const ShHandle handle);
// Return the currently set language output type. // Return the currently set language output type.
COMPILER_EXPORT ShShaderOutput ShGetShaderOutputType( COMPILER_EXPORT ShShaderOutput ShGetShaderOutputType(
const ShHandle handle); const ShHandle handle);
// Returns null-terminated information log for a compiled shader. // Returns null-terminated information log for a compiled shader.
// Parameters: // Parameters:
// handle: Specifies the compiler // handle: Specifies the compiler
COMPILER_EXPORT const std::string &ShGetInfoLog(const ShHandle handle); COMPILER_EXPORT const std::string &ShGetInfoLog(const ShHandle handle);
// Returns null-terminated object code for a compiled shader. // Returns null-terminated object code for a compiled shader.
// Parameters: // Parameters:
// handle: Specifies the compiler // handle: Specifies the compiler
COMPILER_EXPORT const std::string &ShGetObjectCode(const ShHandle handle); COMPILER_EXPORT const std::string &ShGetObjectCode(const ShHandle handle);
// Returns a (original_name, hash) map containing all the user defined // Returns a (original_name, hash) map containing all the user defined
// names in the shader, including variable names, function names, struct // names in the shader, including variable names, function names, struct
// names, and struct field names. // names, and struct field names.
// Parameters: // Parameters:
// handle: Specifies the compiler // handle: Specifies the compiler
COMPILER_EXPORT const std::map<std::string, std::string> *ShGetNameHashingMap( COMPILER_EXPORT const std::map<std::string, std::string> *ShGetNameHashingMap(
const ShHandle handle); const ShHandle handle);
// Shader variable inspection. // Shader variable inspection.
// Returns a pointer to a list of variables of the designated type. // Returns a pointer to a list of variables of the designated type.
// (See ShaderVars.h for type definitions, included above) // (See ShaderVars.h for type definitions, included above)
// Returns NULL on failure. // Returns NULL on failure.
// Parameters: // Parameters:
// handle: Specifies the compiler // handle: Specifies the compiler
COMPILER_EXPORT const std::vector<sh::Uniform> *ShGetUniforms(const ShHandle handle); COMPILER_EXPORT const std::vector<sh::Uniform> *ShGetUniforms(const ShHandle handle);
COMPILER_EXPORT const std::vector<sh::Varying> *ShGetVaryings(const ShHandle handle); COMPILER_EXPORT const std::vector<sh::Varying> *ShGetVaryings(const ShHandle handle);
COMPILER_EXPORT const std::vector<sh::Attribute> *ShGetAttributes(const ShHandle handle); COMPILER_EXPORT const std::vector<sh::Attribute> *ShGetAttributes(const ShHandle handle);
COMPILER_EXPORT const std::vector<sh::Attribute> *ShGetOutputVariables(const ShHandle handle); COMPILER_EXPORT const std::vector<sh::Attribute> *ShGetOutputVariables(const ShHandle handle);
COMPILER_EXPORT const std::vector<sh::InterfaceBlock> *ShGetInterfaceBlocks(const ShHandle handle); COMPILER_EXPORT const std::vector<sh::InterfaceBlock> *ShGetInterfaceBlocks(const ShHandle handle);
typedef struct typedef struct
{ {
sh::GLenum type; sh::GLenum type;
int size; int size;
} ShVariableInfo; } ShVariableInfo;
// Returns true if the passed in variables pack in maxVectors following // Returns true if the passed in variables pack in maxVectors following
// the packing rules from the GLSL 1.017 spec, Appendix A, section 7. // the packing rules from the GLSL 1.017 spec, Appendix A, section 7.
// Returns false otherwise. Also look at the SH_ENFORCE_PACKING_RESTRICTIONS // Returns false otherwise. Also look at the SH_ENFORCE_PACKING_RESTRICTIONS
// flag above. // flag above.
// Parameters: // Parameters:
// maxVectors: the available rows of registers. // maxVectors: the available rows of registers.
// varInfoArray: an array of variable info (types and sizes). // varInfoArray: an array of variable info (types and sizes).
// varInfoArraySize: the size of the variable array. // varInfoArraySize: the size of the variable array.
COMPILER_EXPORT bool ShCheckVariablesWithinPackingLimits( COMPILER_EXPORT bool ShCheckVariablesWithinPackingLimits(
int maxVectors, int maxVectors,
ShVariableInfo *varInfoArray, ShVariableInfo *varInfoArray,
size_t varInfoArraySize); size_t varInfoArraySize);
// Gives the compiler-assigned register for an interface block. // Gives the compiler-assigned register for an interface block.
// The method writes the value to the output variable "indexOut". // The method writes the value to the output variable "indexOut".
// Returns true if it found a valid interface block, false otherwise. // Returns true if it found a valid interface block, false otherwise.
// Parameters: // Parameters:
// handle: Specifies the compiler // handle: Specifies the compiler
// interfaceBlockName: Specifies the interface block // interfaceBlockName: Specifies the interface block
// indexOut: output variable that stores the assigned register // indexOut: output variable that stores the assigned register
COMPILER_EXPORT bool ShGetInterfaceBlockRegister(const ShHandle handle, COMPILER_EXPORT bool ShGetInterfaceBlockRegister(const ShHandle handle,
const std::string &interfaceBlockName, const std::string &interfaceBlockName,
unsigned int *indexOut); unsigned int *indexOut);
// Gives the compiler-assigned register for uniforms in the default // Gives the compiler-assigned register for uniforms in the default
// interface block. // interface block.
// The method writes the value to the output variable "indexOut". // The method writes the value to the output variable "indexOut".
// Returns true if it found a valid default uniform, false otherwise. // Returns true if it found a valid default uniform, false otherwise.
// Parameters: // Parameters:
// handle: Specifies the compiler // handle: Specifies the compiler
// interfaceBlockName: Specifies the uniform // interfaceBlockName: Specifies the uniform
// indexOut: output variable that stores the assigned register // indexOut: output variable that stores the assigned register
COMPILER_EXPORT bool ShGetUniformRegister(const ShHandle handle, COMPILER_EXPORT bool ShGetUniformRegister(const ShHandle handle,
const std::string &uniformName, const std::string &uniformName,
unsigned int *indexOut); unsigned int *indexOut);
#endif // _COMPILER_INTERFACE_INCLUDED_ #endif // _COMPILER_INTERFACE_INCLUDED_

370
platform/winrt/include/GLSLANG/ShaderVars.h
View file

@ -1,185 +1,185 @@
// //
// Copyright (c) 2013-2014 The ANGLE Project Authors. All rights reserved. // Copyright (c) 2013-2014 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be // Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. // found in the LICENSE file.
// //
// ShaderVars.h: // ShaderVars.h:
// Types to represent GL variables (varyings, uniforms, etc) // Types to represent GL variables (varyings, uniforms, etc)
// //
#ifndef _COMPILER_INTERFACE_VARIABLES_ #ifndef _COMPILER_INTERFACE_VARIABLES_
#define _COMPILER_INTERFACE_VARIABLES_ #define _COMPILER_INTERFACE_VARIABLES_
#include <string> #include <string>
#include <vector> #include <vector>
#include <algorithm> #include <algorithm>
// Assume ShaderLang.h is included before ShaderVars.h, for sh::GLenum // Assume ShaderLang.h is included before ShaderVars.h, for sh::GLenum
// Note: make sure to increment ANGLE_SH_VERSION when changing ShaderVars.h // Note: make sure to increment ANGLE_SH_VERSION when changing ShaderVars.h
namespace sh namespace sh
{ {
// Varying interpolation qualifier, see section 4.3.9 of the ESSL 3.00.4 spec // Varying interpolation qualifier, see section 4.3.9 of the ESSL 3.00.4 spec
enum InterpolationType enum InterpolationType
{ {
INTERPOLATION_SMOOTH, INTERPOLATION_SMOOTH,
INTERPOLATION_CENTROID, INTERPOLATION_CENTROID,
INTERPOLATION_FLAT INTERPOLATION_FLAT
}; };
// Uniform block layout qualifier, see section 4.3.8.3 of the ESSL 3.00.4 spec // Uniform block layout qualifier, see section 4.3.8.3 of the ESSL 3.00.4 spec
enum BlockLayoutType enum BlockLayoutType
{ {
BLOCKLAYOUT_STANDARD, BLOCKLAYOUT_STANDARD,
BLOCKLAYOUT_PACKED, BLOCKLAYOUT_PACKED,
BLOCKLAYOUT_SHARED BLOCKLAYOUT_SHARED
}; };
// Base class for all variables defined in shaders, including Varyings, Uniforms, etc // Base class for all variables defined in shaders, including Varyings, Uniforms, etc
// Note: we must override the copy constructor and assignment operator so we can // Note: we must override the copy constructor and assignment operator so we can
// work around excessive GCC binary bloating: // work around excessive GCC binary bloating:
// See https://code.google.com/p/angleproject/issues/detail?id=697 // See https://code.google.com/p/angleproject/issues/detail?id=697
struct COMPILER_EXPORT ShaderVariable struct COMPILER_EXPORT ShaderVariable
{ {
ShaderVariable(); ShaderVariable();
ShaderVariable(GLenum typeIn, unsigned int arraySizeIn); ShaderVariable(GLenum typeIn, unsigned int arraySizeIn);
~ShaderVariable(); ~ShaderVariable();
ShaderVariable(const ShaderVariable &other); ShaderVariable(const ShaderVariable &other);
ShaderVariable &operator=(const ShaderVariable &other); ShaderVariable &operator=(const ShaderVariable &other);
bool isArray() const { return arraySize > 0; } bool isArray() const { return arraySize > 0; }
unsigned int elementCount() const { return std::max(1u, arraySize); } unsigned int elementCount() const { return std::max(1u, arraySize); }
bool isStruct() const { return !fields.empty(); } bool isStruct() const { return !fields.empty(); }
// All of the shader's variables are described using nested data // All of the shader's variables are described using nested data
// structures. This is needed in order to disambiguate similar looking // structures. This is needed in order to disambiguate similar looking
// types, such as two structs containing the same fields, but in // types, such as two structs containing the same fields, but in
// different orders. "findInfoByMappedName" provides an easy query for // different orders. "findInfoByMappedName" provides an easy query for
// users to dive into the data structure and fetch the unique variable // users to dive into the data structure and fetch the unique variable
// instance corresponding to a dereferencing chain of the top-level // instance corresponding to a dereferencing chain of the top-level
// variable. // variable.
// Given a mapped name like 'a[0].b.c[0]', return the ShaderVariable // Given a mapped name like 'a[0].b.c[0]', return the ShaderVariable
// that defines 'c' in |leafVar|, and the original name 'A[0].B.C[0]' // that defines 'c' in |leafVar|, and the original name 'A[0].B.C[0]'
// in |originalName|, based on the assumption that |this| defines 'a'. // in |originalName|, based on the assumption that |this| defines 'a'.
// If no match is found, return false. // If no match is found, return false.
bool findInfoByMappedName(const std::string &mappedFullName, bool findInfoByMappedName(const std::string &mappedFullName,
const ShaderVariable **leafVar, const ShaderVariable **leafVar,
std::string* originalFullName) const; std::string* originalFullName) const;
GLenum type; GLenum type;
GLenum precision; GLenum precision;
std::string name; std::string name;
std::string mappedName; std::string mappedName;
unsigned int arraySize; unsigned int arraySize;
bool staticUse; bool staticUse;
std::vector<ShaderVariable> fields; std::vector<ShaderVariable> fields;
std::string structName; std::string structName;
protected: protected:
bool isSameVariableAtLinkTime(const ShaderVariable &other, bool isSameVariableAtLinkTime(const ShaderVariable &other,
bool matchPrecision) const; bool matchPrecision) const;
bool operator==(const ShaderVariable &other) const; bool operator==(const ShaderVariable &other) const;
bool operator!=(const ShaderVariable &other) const bool operator!=(const ShaderVariable &other) const
{ {
return !operator==(other); return !operator==(other);
} }
}; };
struct COMPILER_EXPORT Uniform : public ShaderVariable struct COMPILER_EXPORT Uniform : public ShaderVariable
{ {
Uniform(); Uniform();
~Uniform(); ~Uniform();
Uniform(const Uniform &other); Uniform(const Uniform &other);
Uniform &operator=(const Uniform &other); Uniform &operator=(const Uniform &other);
bool operator==(const Uniform &other) const; bool operator==(const Uniform &other) const;
bool operator!=(const Uniform &other) const bool operator!=(const Uniform &other) const
{ {
return !operator==(other); return !operator==(other);
} }
// Decide whether two uniforms are the same at shader link time, // Decide whether two uniforms are the same at shader link time,
// assuming one from vertex shader and the other from fragment shader. // assuming one from vertex shader and the other from fragment shader.
// See GLSL ES Spec 3.00.3, sec 4.3.5. // See GLSL ES Spec 3.00.3, sec 4.3.5.
bool isSameUniformAtLinkTime(const Uniform &other) const; bool isSameUniformAtLinkTime(const Uniform &other) const;
}; };
struct COMPILER_EXPORT Attribute : public ShaderVariable struct COMPILER_EXPORT Attribute : public ShaderVariable
{ {
Attribute(); Attribute();
~Attribute(); ~Attribute();
Attribute(const Attribute &other); Attribute(const Attribute &other);
Attribute &operator=(const Attribute &other); Attribute &operator=(const Attribute &other);
bool operator==(const Attribute &other) const; bool operator==(const Attribute &other) const;
bool operator!=(const Attribute &other) const bool operator!=(const Attribute &other) const
{ {
return !operator==(other); return !operator==(other);
} }
int location; int location;
}; };
struct COMPILER_EXPORT InterfaceBlockField : public ShaderVariable struct COMPILER_EXPORT InterfaceBlockField : public ShaderVariable
{ {
InterfaceBlockField(); InterfaceBlockField();
~InterfaceBlockField(); ~InterfaceBlockField();
InterfaceBlockField(const InterfaceBlockField &other); InterfaceBlockField(const InterfaceBlockField &other);
InterfaceBlockField &operator=(const InterfaceBlockField &other); InterfaceBlockField &operator=(const InterfaceBlockField &other);
bool operator==(const InterfaceBlockField &other) const; bool operator==(const InterfaceBlockField &other) const;
bool operator!=(const InterfaceBlockField &other) const bool operator!=(const InterfaceBlockField &other) const
{ {
return !operator==(other); return !operator==(other);
} }
// Decide whether two InterfaceBlock fields are the same at shader // Decide whether two InterfaceBlock fields are the same at shader
// link time, assuming one from vertex shader and the other from // link time, assuming one from vertex shader and the other from
// fragment shader. // fragment shader.
// See GLSL ES Spec 3.00.3, sec 4.3.7. // See GLSL ES Spec 3.00.3, sec 4.3.7.
bool isSameInterfaceBlockFieldAtLinkTime( bool isSameInterfaceBlockFieldAtLinkTime(
const InterfaceBlockField &other) const; const InterfaceBlockField &other) const;
bool isRowMajorLayout; bool isRowMajorLayout;
}; };
struct COMPILER_EXPORT Varying : public ShaderVariable struct COMPILER_EXPORT Varying : public ShaderVariable
{ {
Varying(); Varying();
~Varying(); ~Varying();
Varying(const Varying &otherg); Varying(const Varying &otherg);
Varying &operator=(const Varying &other); Varying &operator=(const Varying &other);
bool operator==(const Varying &other) const; bool operator==(const Varying &other) const;
bool operator!=(const Varying &other) const bool operator!=(const Varying &other) const
{ {
return !operator==(other); return !operator==(other);
} }
// Decide whether two varyings are the same at shader link time, // Decide whether two varyings are the same at shader link time,
// assuming one from vertex shader and the other from fragment shader. // assuming one from vertex shader and the other from fragment shader.
// See GLSL ES Spec 3.00.3, sec 4.3.9. // See GLSL ES Spec 3.00.3, sec 4.3.9.
bool isSameVaryingAtLinkTime(const Varying &other) const; bool isSameVaryingAtLinkTime(const Varying &other) const;
InterpolationType interpolation; InterpolationType interpolation;
bool isInvariant; bool isInvariant;
}; };
struct COMPILER_EXPORT InterfaceBlock struct COMPILER_EXPORT InterfaceBlock
{ {
InterfaceBlock(); InterfaceBlock();
~InterfaceBlock(); ~InterfaceBlock();
InterfaceBlock(const InterfaceBlock &other); InterfaceBlock(const InterfaceBlock &other);
InterfaceBlock &operator=(const InterfaceBlock &other); InterfaceBlock &operator=(const InterfaceBlock &other);
std::string name; std::string name;
std::string mappedName; std::string mappedName;
std::string instanceName; std::string instanceName;
unsigned int arraySize; unsigned int arraySize;
BlockLayoutType layout; BlockLayoutType layout;
bool isRowMajorLayout; bool isRowMajorLayout;
bool staticUse; bool staticUse;
std::vector<InterfaceBlockField> fields; std::vector<InterfaceBlockField> fields;
}; };
} }
#endif // _COMPILER_INTERFACE_VARIABLES_ #endif // _COMPILER_INTERFACE_VARIABLES_

564
platform/winrt/include/KHR/khrplatform.h
View file

@ -1,282 +1,282 @@
#ifndef __khrplatform_h_ #ifndef __khrplatform_h_
#define __khrplatform_h_ #define __khrplatform_h_
/* /*
** Copyright (c) 2008-2009 The Khronos Group Inc. ** Copyright (c) 2008-2009 The Khronos Group Inc.
** **
** Permission is hereby granted, free of charge, to any person obtaining a ** Permission is hereby granted, free of charge, to any person obtaining a
** copy of this software and/or associated documentation files (the ** copy of this software and/or associated documentation files (the
** "Materials"), to deal in the Materials without restriction, including ** "Materials"), to deal in the Materials without restriction, including
** without limitation the rights to use, copy, modify, merge, publish, ** without limitation the rights to use, copy, modify, merge, publish,
** distribute, sublicense, and/or sell copies of the Materials, and to ** distribute, sublicense, and/or sell copies of the Materials, and to
** permit persons to whom the Materials are furnished to do so, subject to ** permit persons to whom the Materials are furnished to do so, subject to
** the following conditions: ** the following conditions:
** **
** The above copyright notice and this permission notice shall be included ** The above copyright notice and this permission notice shall be included
** in all copies or substantial portions of the Materials. ** in all copies or substantial portions of the Materials.
** **
** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, ** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF ** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. ** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY ** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, ** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE ** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS. ** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.
*/ */
/* Khronos platform-specific types and definitions. /* Khronos platform-specific types and definitions.
* *
* $Revision: 23298 $ on $Date: 2013-09-30 17:07:13 -0700 (Mon, 30 Sep 2013) $ * $Revision: 23298 $ on $Date: 2013-09-30 17:07:13 -0700 (Mon, 30 Sep 2013) $
* *
* Adopters may modify this file to suit their platform. Adopters are * Adopters may modify this file to suit their platform. Adopters are
* encouraged to submit platform specific modifications to the Khronos * encouraged to submit platform specific modifications to the Khronos
* group so that they can be included in future versions of this file. * group so that they can be included in future versions of this file.
* Please submit changes by sending them to the public Khronos Bugzilla * Please submit changes by sending them to the public Khronos Bugzilla
* (http://khronos.org/bugzilla) by filing a bug against product * (http://khronos.org/bugzilla) by filing a bug against product
* "Khronos (general)" component "Registry". * "Khronos (general)" component "Registry".
* *
* A predefined template which fills in some of the bug fields can be * A predefined template which fills in some of the bug fields can be
* reached using http://tinyurl.com/khrplatform-h-bugreport, but you * reached using http://tinyurl.com/khrplatform-h-bugreport, but you
* must create a Bugzilla login first. * must create a Bugzilla login first.
* *
* *
* See the Implementer's Guidelines for information about where this file * See the Implementer's Guidelines for information about where this file
* should be located on your system and for more details of its use: * should be located on your system and for more details of its use:
* http://www.khronos.org/registry/implementers_guide.pdf * http://www.khronos.org/registry/implementers_guide.pdf
* *
* This file should be included as * This file should be included as
* #include <KHR/khrplatform.h> * #include <KHR/khrplatform.h>
* by Khronos client API header files that use its types and defines. * by Khronos client API header files that use its types and defines.
* *
* The types in khrplatform.h should only be used to define API-specific types. * The types in khrplatform.h should only be used to define API-specific types.
* *
* Types defined in khrplatform.h: * Types defined in khrplatform.h:
* khronos_int8_t signed 8 bit * khronos_int8_t signed 8 bit
* khronos_uint8_t unsigned 8 bit * khronos_uint8_t unsigned 8 bit
* khronos_int16_t signed 16 bit * khronos_int16_t signed 16 bit
* khronos_uint16_t unsigned 16 bit * khronos_uint16_t unsigned 16 bit
* khronos_int32_t signed 32 bit * khronos_int32_t signed 32 bit
* khronos_uint32_t unsigned 32 bit * khronos_uint32_t unsigned 32 bit
* khronos_int64_t signed 64 bit * khronos_int64_t signed 64 bit
* khronos_uint64_t unsigned 64 bit * khronos_uint64_t unsigned 64 bit
* khronos_intptr_t signed same number of bits as a pointer * khronos_intptr_t signed same number of bits as a pointer
* khronos_uintptr_t unsigned same number of bits as a pointer * khronos_uintptr_t unsigned same number of bits as a pointer
* khronos_ssize_t signed size * khronos_ssize_t signed size
* khronos_usize_t unsigned size * khronos_usize_t unsigned size
* khronos_float_t signed 32 bit floating point * khronos_float_t signed 32 bit floating point
* khronos_time_ns_t unsigned 64 bit time in nanoseconds * khronos_time_ns_t unsigned 64 bit time in nanoseconds
* khronos_utime_nanoseconds_t unsigned time interval or absolute time in * khronos_utime_nanoseconds_t unsigned time interval or absolute time in
* nanoseconds * nanoseconds
* khronos_stime_nanoseconds_t signed time interval in nanoseconds * khronos_stime_nanoseconds_t signed time interval in nanoseconds
* khronos_boolean_enum_t enumerated boolean type. This should * khronos_boolean_enum_t enumerated boolean type. This should
* only be used as a base type when a client API's boolean type is * only be used as a base type when a client API's boolean type is
* an enum. Client APIs which use an integer or other type for * an enum. Client APIs which use an integer or other type for
* booleans cannot use this as the base type for their boolean. * booleans cannot use this as the base type for their boolean.
* *
* Tokens defined in khrplatform.h: * Tokens defined in khrplatform.h:
* *
* KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values. * KHRONOS_FALSE, KHRONOS_TRUE Enumerated boolean false/true values.
* *
* KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0. * KHRONOS_SUPPORT_INT64 is 1 if 64 bit integers are supported; otherwise 0.
* KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0. * KHRONOS_SUPPORT_FLOAT is 1 if floats are supported; otherwise 0.
* *
* Calling convention macros defined in this file: * Calling convention macros defined in this file:
* KHRONOS_APICALL * KHRONOS_APICALL
* KHRONOS_APIENTRY * KHRONOS_APIENTRY
* KHRONOS_APIATTRIBUTES * KHRONOS_APIATTRIBUTES
* *
* These may be used in function prototypes as: * These may be used in function prototypes as:
* *
* KHRONOS_APICALL void KHRONOS_APIENTRY funcname( * KHRONOS_APICALL void KHRONOS_APIENTRY funcname(
* int arg1, * int arg1,
* int arg2) KHRONOS_APIATTRIBUTES; * int arg2) KHRONOS_APIATTRIBUTES;
*/ */
/*------------------------------------------------------------------------- /*-------------------------------------------------------------------------
* Definition of KHRONOS_APICALL * Definition of KHRONOS_APICALL
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
* This precedes the return type of the function in the function prototype. * This precedes the return type of the function in the function prototype.
*/ */
#if defined(_WIN32) && !defined(__SCITECH_SNAP__) #if defined(_WIN32) && !defined(__SCITECH_SNAP__)
# define KHRONOS_APICALL __declspec(dllimport) # define KHRONOS_APICALL __declspec(dllimport)
#elif defined (__SYMBIAN32__) #elif defined (__SYMBIAN32__)
# define KHRONOS_APICALL IMPORT_C # define KHRONOS_APICALL IMPORT_C
#else #else
# define KHRONOS_APICALL # define KHRONOS_APICALL
#endif #endif
/*------------------------------------------------------------------------- /*-------------------------------------------------------------------------
* Definition of KHRONOS_APIENTRY * Definition of KHRONOS_APIENTRY
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
* This follows the return type of the function and precedes the function * This follows the return type of the function and precedes the function
* name in the function prototype. * name in the function prototype.
*/ */
#if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__) #if defined(_WIN32) && !defined(_WIN32_WCE) && !defined(__SCITECH_SNAP__)
/* Win32 but not WinCE */ /* Win32 but not WinCE */
# define KHRONOS_APIENTRY __stdcall # define KHRONOS_APIENTRY __stdcall
#else #else
# define KHRONOS_APIENTRY # define KHRONOS_APIENTRY
#endif #endif
/*------------------------------------------------------------------------- /*-------------------------------------------------------------------------
* Definition of KHRONOS_APIATTRIBUTES * Definition of KHRONOS_APIATTRIBUTES
*------------------------------------------------------------------------- *-------------------------------------------------------------------------
* This follows the closing parenthesis of the function prototype arguments. * This follows the closing parenthesis of the function prototype arguments.
*/ */
#if defined (__ARMCC_2__) #if defined (__ARMCC_2__)
#define KHRONOS_APIATTRIBUTES __softfp #define KHRONOS_APIATTRIBUTES __softfp
#else #else
#define KHRONOS_APIATTRIBUTES #define KHRONOS_APIATTRIBUTES
#endif #endif
/*------------------------------------------------------------------------- /*-------------------------------------------------------------------------
* basic type definitions * basic type definitions
*-----------------------------------------------------------------------*/ *-----------------------------------------------------------------------*/
#if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__) #if (defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L) || defined(__GNUC__) || defined(__SCO__) || defined(__USLC__)
/* /*
* Using <stdint.h> * Using <stdint.h>
*/ */
#include <stdint.h> #include <stdint.h>
typedef int32_t khronos_int32_t; typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t; typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t; typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t; typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1 #define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1 #define KHRONOS_SUPPORT_FLOAT 1
#elif defined(__VMS ) || defined(__sgi) #elif defined(__VMS ) || defined(__sgi)
/* /*
* Using <inttypes.h> * Using <inttypes.h>
*/ */
#include <inttypes.h> #include <inttypes.h>
typedef int32_t khronos_int32_t; typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t; typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t; typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t; typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1 #define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1 #define KHRONOS_SUPPORT_FLOAT 1
#elif defined(_WIN32) && !defined(__SCITECH_SNAP__) #elif defined(_WIN32) && !defined(__SCITECH_SNAP__)
/* /*
* Win32 * Win32
*/ */
typedef __int32 khronos_int32_t; typedef __int32 khronos_int32_t;
typedef unsigned __int32 khronos_uint32_t; typedef unsigned __int32 khronos_uint32_t;
typedef __int64 khronos_int64_t; typedef __int64 khronos_int64_t;
typedef unsigned __int64 khronos_uint64_t; typedef unsigned __int64 khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1 #define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1 #define KHRONOS_SUPPORT_FLOAT 1
#elif defined(__sun__) || defined(__digital__) #elif defined(__sun__) || defined(__digital__)
/* /*
* Sun or Digital * Sun or Digital
*/ */
typedef int khronos_int32_t; typedef int khronos_int32_t;
typedef unsigned int khronos_uint32_t; typedef unsigned int khronos_uint32_t;
#if defined(__arch64__) || defined(_LP64) #if defined(__arch64__) || defined(_LP64)
typedef long int khronos_int64_t; typedef long int khronos_int64_t;
typedef unsigned long int khronos_uint64_t; typedef unsigned long int khronos_uint64_t;
#else #else
typedef long long int khronos_int64_t; typedef long long int khronos_int64_t;
typedef unsigned long long int khronos_uint64_t; typedef unsigned long long int khronos_uint64_t;
#endif /* __arch64__ */ #endif /* __arch64__ */
#define KHRONOS_SUPPORT_INT64 1 #define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1 #define KHRONOS_SUPPORT_FLOAT 1
#elif 0 #elif 0
/* /*
* Hypothetical platform with no float or int64 support * Hypothetical platform with no float or int64 support
*/ */
typedef int khronos_int32_t; typedef int khronos_int32_t;
typedef unsigned int khronos_uint32_t; typedef unsigned int khronos_uint32_t;
#define KHRONOS_SUPPORT_INT64 0 #define KHRONOS_SUPPORT_INT64 0
#define KHRONOS_SUPPORT_FLOAT 0 #define KHRONOS_SUPPORT_FLOAT 0
#else #else
/* /*
* Generic fallback * Generic fallback
*/ */
#include <stdint.h> #include <stdint.h>
typedef int32_t khronos_int32_t; typedef int32_t khronos_int32_t;
typedef uint32_t khronos_uint32_t; typedef uint32_t khronos_uint32_t;
typedef int64_t khronos_int64_t; typedef int64_t khronos_int64_t;
typedef uint64_t khronos_uint64_t; typedef uint64_t khronos_uint64_t;
#define KHRONOS_SUPPORT_INT64 1 #define KHRONOS_SUPPORT_INT64 1
#define KHRONOS_SUPPORT_FLOAT 1 #define KHRONOS_SUPPORT_FLOAT 1
#endif #endif
/* /*
* Types that are (so far) the same on all platforms * Types that are (so far) the same on all platforms
*/ */
typedef signed char khronos_int8_t; typedef signed char khronos_int8_t;
typedef unsigned char khronos_uint8_t; typedef unsigned char khronos_uint8_t;
typedef signed short int khronos_int16_t; typedef signed short int khronos_int16_t;
typedef unsigned short int khronos_uint16_t; typedef unsigned short int khronos_uint16_t;
/* /*
* Types that differ between LLP64 and LP64 architectures - in LLP64, * Types that differ between LLP64 and LP64 architectures - in LLP64,
* pointers are 64 bits, but 'long' is still 32 bits. Win64 appears * pointers are 64 bits, but 'long' is still 32 bits. Win64 appears
* to be the only LLP64 architecture in current use. * to be the only LLP64 architecture in current use.
*/ */
#ifdef _WIN64 #ifdef _WIN64
typedef signed long long int khronos_intptr_t; typedef signed long long int khronos_intptr_t;
typedef unsigned long long int khronos_uintptr_t; typedef unsigned long long int khronos_uintptr_t;
typedef signed long long int khronos_ssize_t; typedef signed long long int khronos_ssize_t;
typedef unsigned long long int khronos_usize_t; typedef unsigned long long int khronos_usize_t;
#else #else
typedef signed long int khronos_intptr_t; typedef signed long int khronos_intptr_t;
typedef unsigned long int khronos_uintptr_t; typedef unsigned long int khronos_uintptr_t;
typedef signed long int khronos_ssize_t; typedef signed long int khronos_ssize_t;
typedef unsigned long int khronos_usize_t; typedef unsigned long int khronos_usize_t;
#endif #endif
#if KHRONOS_SUPPORT_FLOAT #if KHRONOS_SUPPORT_FLOAT
/* /*
* Float type * Float type
*/ */
typedef float khronos_float_t; typedef float khronos_float_t;
#endif #endif
#if KHRONOS_SUPPORT_INT64 #if KHRONOS_SUPPORT_INT64
/* Time types /* Time types
* *
* These types can be used to represent a time interval in nanoseconds or * These types can be used to represent a time interval in nanoseconds or
* an absolute Unadjusted System Time. Unadjusted System Time is the number * an absolute Unadjusted System Time. Unadjusted System Time is the number
* of nanoseconds since some arbitrary system event (e.g. since the last * of nanoseconds since some arbitrary system event (e.g. since the last
* time the system booted). The Unadjusted System Time is an unsigned * time the system booted). The Unadjusted System Time is an unsigned
* 64 bit value that wraps back to 0 every 584 years. Time intervals * 64 bit value that wraps back to 0 every 584 years. Time intervals
* may be either signed or unsigned. * may be either signed or unsigned.
*/ */
typedef khronos_uint64_t khronos_utime_nanoseconds_t; typedef khronos_uint64_t khronos_utime_nanoseconds_t;
typedef khronos_int64_t khronos_stime_nanoseconds_t; typedef khronos_int64_t khronos_stime_nanoseconds_t;
#endif #endif
/* /*
* Dummy value used to pad enum types to 32 bits. * Dummy value used to pad enum types to 32 bits.
*/ */
#ifndef KHRONOS_MAX_ENUM #ifndef KHRONOS_MAX_ENUM
#define KHRONOS_MAX_ENUM 0x7FFFFFFF #define KHRONOS_MAX_ENUM 0x7FFFFFFF
#endif #endif
/* /*
* Enumerated boolean type * Enumerated boolean type
* *
* Values other than zero should be considered to be true. Therefore * Values other than zero should be considered to be true. Therefore
* comparisons should not be made against KHRONOS_TRUE. * comparisons should not be made against KHRONOS_TRUE.
*/ */
typedef enum { typedef enum {
KHRONOS_FALSE = 0, KHRONOS_FALSE = 0,
KHRONOS_TRUE = 1, KHRONOS_TRUE = 1,
KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM KHRONOS_BOOLEAN_ENUM_FORCE_SIZE = KHRONOS_MAX_ENUM
} khronos_boolean_enum_t; } khronos_boolean_enum_t;
#endif /* __khrplatform_h_ */ #endif /* __khrplatform_h_ */

46
platform/winrt/include/angle_gl.h
View file

@ -1,23 +1,23 @@
// //
// Copyright (c) 2014 The ANGLE Project Authors. All rights reserved. // Copyright (c) 2014 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be // Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. // found in the LICENSE file.
// //
// angle_gl.h: // angle_gl.h:
// Includes all necessary GL headers and definitions for ANGLE. // Includes all necessary GL headers and definitions for ANGLE.
// //
#ifndef ANGLE_GL_H_ #ifndef ANGLE_GL_H_
#define ANGLE_GL_H_ #define ANGLE_GL_H_
#include "GLES2/gl2.h" #include "GLES2/gl2.h"
#include "GLES2/gl2ext.h" #include "GLES2/gl2ext.h"
#include "GLES3/gl3.h" #include "GLES3/gl3.h"
#include "GLES3/gl3ext.h" #include "GLES3/gl3ext.h"
// The following enum is used in ANGLE, but is from desktop GL // The following enum is used in ANGLE, but is from desktop GL
#ifndef GL_SAMPLER_2D_RECT_ARB #ifndef GL_SAMPLER_2D_RECT_ARB
#define GL_SAMPLER_2D_RECT_ARB 0x8B63 #define GL_SAMPLER_2D_RECT_ARB 0x8B63
#endif #endif
#endif // ANGLE_GL_H_ #endif // ANGLE_GL_H_

74
platform/winrt/include/angle_windowsstore.h
View file

@ -1,37 +1,37 @@
// //
// Copyright (c) 2014 The ANGLE Project Authors. All rights reserved. // Copyright (c) 2014 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be // Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. // found in the LICENSE file.
// //
// angle_windowsstore.h: // angle_windowsstore.h:
#ifndef ANGLE_WINDOWSSTORE_H_ #ifndef ANGLE_WINDOWSSTORE_H_
#define ANGLE_WINDOWSSTORE_H_ #define ANGLE_WINDOWSSTORE_H_
// The following properties can be set on the CoreApplication to support additional // The following properties can be set on the CoreApplication to support additional
// ANGLE configuration options. // ANGLE configuration options.
// //
// The Visual Studio sample templates provided with this version of ANGLE have examples // The Visual Studio sample templates provided with this version of ANGLE have examples
// of how to set these property values. // of how to set these property values.
// //
// Property: EGLNativeWindowTypeProperty // Property: EGLNativeWindowTypeProperty
// Type: IInspectable // Type: IInspectable
// Description: Set this property to specify the window type to use for creating a surface. // Description: Set this property to specify the window type to use for creating a surface.
// If this property is missing, surface creation will fail. // If this property is missing, surface creation will fail.
// //
const wchar_t EGLNativeWindowTypeProperty[] = L"EGLNativeWindowTypeProperty"; const wchar_t EGLNativeWindowTypeProperty[] = L"EGLNativeWindowTypeProperty";
// //
// Property: EGLRenderSurfaceSizeProperty // Property: EGLRenderSurfaceSizeProperty
// Type: Size // Type: Size
// Description: Set this property to specify a preferred size in pixels of the render surface. // Description: Set this property to specify a preferred size in pixels of the render surface.
// The render surface size width and height must be greater than 0. // The render surface size width and height must be greater than 0.
// If this property is set, then the render surface size is fixed. // If this property is set, then the render surface size is fixed.
// If this property is missing, a default behavior will be provided. // If this property is missing, a default behavior will be provided.
// The default behavior uses the window size if a CoreWindow is specified or // The default behavior uses the window size if a CoreWindow is specified or
// the size of the SwapChainPanel control if one is specified. // the size of the SwapChainPanel control if one is specified.
// //
const wchar_t EGLRenderSurfaceSizeProperty[] = L"EGLRenderSurfaceSizeProperty"; const wchar_t EGLRenderSurfaceSizeProperty[] = L"EGLRenderSurfaceSizeProperty";
#endif // ANGLE_WINDOWSSTORE_H_ #endif // ANGLE_WINDOWSSTORE_H_

1492
servers/physics/space_sw.cpp
View file

File diff suppressed because it is too large Load diff

374
servers/physics/space_sw.h
View file

@ -1,187 +1,187 @@
/*************************************************************************/ /*************************************************************************/
/* space_sw.h */ /* space_sw.h */
/*************************************************************************/ /*************************************************************************/
/* This file is part of: */ /* This file is part of: */
/* GODOT ENGINE */ /* GODOT ENGINE */
/* http://www.godotengine.org */ /* http://www.godotengine.org */
/*************************************************************************/ /*************************************************************************/
/* Copyright (c) 2007-2015 Juan Linietsky, Ariel Manzur. */ /* Copyright (c) 2007-2015 Juan Linietsky, Ariel Manzur. */
/* */ /* */
/* Permission is hereby granted, free of charge, to any person obtaining */ /* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */ /* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */ /* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */ /* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */ /* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */ /* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */ /* the following conditions: */
/* */ /* */
/* The above copyright notice and this permission notice shall be */ /* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */ /* included in all copies or substantial portions of the Software. */
/* */ /* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/ /*************************************************************************/
#ifndef SPACE_SW_H #ifndef SPACE_SW_H
#define SPACE_SW_H #define SPACE_SW_H
#include "typedefs.h" #include "typedefs.h"
#include "hash_map.h" #include "hash_map.h"
#include "body_sw.h" #include "body_sw.h"
#include "area_sw.h" #include "area_sw.h"
#include "body_pair_sw.h" #include "body_pair_sw.h"
#include "area_pair_sw.h" #include "area_pair_sw.h"
#include "broad_phase_sw.h" #include "broad_phase_sw.h"
#include "collision_object_sw.h" #include "collision_object_sw.h"
class PhysicsDirectSpaceStateSW : public PhysicsDirectSpaceState { class PhysicsDirectSpaceStateSW : public PhysicsDirectSpaceState {
OBJ_TYPE( PhysicsDirectSpaceStateSW, PhysicsDirectSpaceState ); OBJ_TYPE( PhysicsDirectSpaceStateSW, PhysicsDirectSpaceState );
public: public:
SpaceSW *space; SpaceSW *space;
virtual bool intersect_ray(const Vector3& p_from, const Vector3& p_to,RayResult &r_result,const Set<RID>& p_exclude=Set<RID>(),uint32_t p_layer_mask=0xFFFFFFFF,uint32_t p_object_type_mask=TYPE_MASK_COLLISION); virtual bool intersect_ray(const Vector3& p_from, const Vector3& p_to,RayResult &r_result,const Set<RID>& p_exclude=Set<RID>(),uint32_t p_layer_mask=0xFFFFFFFF,uint32_t p_object_type_mask=TYPE_MASK_COLLISION);
virtual int intersect_shape(const RID& p_shape, const Transform& p_xform,float p_margin,ShapeResult *r_results,int p_result_max,const Set<RID>& p_exclude=Set<RID>(),uint32_t p_layer_mask=0xFFFFFFFF,uint32_t p_object_type_mask=TYPE_MASK_COLLISION); virtual int intersect_shape(const RID& p_shape, const Transform& p_xform,float p_margin,ShapeResult *r_results,int p_result_max,const Set<RID>& p_exclude=Set<RID>(),uint32_t p_layer_mask=0xFFFFFFFF,uint32_t p_object_type_mask=TYPE_MASK_COLLISION);
virtual bool cast_motion(const RID& p_shape, const Transform& p_xform,const Vector3& p_motion,float p_margin,float &p_closest_safe,float &p_closest_unsafe, const Set<RID>& p_exclude=Set<RID>(),uint32_t p_layer_mask=0xFFFFFFFF,uint32_t p_object_type_mask=TYPE_MASK_COLLISION,ShapeRestInfo *r_info=NULL); virtual bool cast_motion(const RID& p_shape, const Transform& p_xform,const Vector3& p_motion,float p_margin,float &p_closest_safe,float &p_closest_unsafe, const Set<RID>& p_exclude=Set<RID>(),uint32_t p_layer_mask=0xFFFFFFFF,uint32_t p_object_type_mask=TYPE_MASK_COLLISION,ShapeRestInfo *r_info=NULL);
virtual bool collide_shape(RID p_shape, const Transform& p_shape_xform,float p_margin,Vector3 *r_results,int p_result_max,int &r_result_count, const Set<RID>& p_exclude=Set<RID>(),uint32_t p_layer_mask=0xFFFFFFFF,uint32_t p_object_type_mask=TYPE_MASK_COLLISION); virtual bool collide_shape(RID p_shape, const Transform& p_shape_xform,float p_margin,Vector3 *r_results,int p_result_max,int &r_result_count, const Set<RID>& p_exclude=Set<RID>(),uint32_t p_layer_mask=0xFFFFFFFF,uint32_t p_object_type_mask=TYPE_MASK_COLLISION);
virtual bool rest_info(RID p_shape, const Transform& p_shape_xform,float p_margin,ShapeRestInfo *r_info, const Set<RID>& p_exclude=Set<RID>(),uint32_t p_layer_mask=0xFFFFFFFF,uint32_t p_object_type_mask=TYPE_MASK_COLLISION); virtual bool rest_info(RID p_shape, const Transform& p_shape_xform,float p_margin,ShapeRestInfo *r_info, const Set<RID>& p_exclude=Set<RID>(),uint32_t p_layer_mask=0xFFFFFFFF,uint32_t p_object_type_mask=TYPE_MASK_COLLISION);
PhysicsDirectSpaceStateSW(); PhysicsDirectSpaceStateSW();
}; };
class SpaceSW { class SpaceSW {
PhysicsDirectSpaceStateSW *direct_access; PhysicsDirectSpaceStateSW *direct_access;
RID self; RID self;
BroadPhaseSW *broadphase; BroadPhaseSW *broadphase;
SelfList<BodySW>::List active_list; SelfList<BodySW>::List active_list;
SelfList<BodySW>::List inertia_update_list; SelfList<BodySW>::List inertia_update_list;
SelfList<BodySW>::List state_query_list; SelfList<BodySW>::List state_query_list;
SelfList<AreaSW>::List monitor_query_list; SelfList<AreaSW>::List monitor_query_list;
SelfList<AreaSW>::List area_moved_list; SelfList<AreaSW>::List area_moved_list;
static void* _broadphase_pair(CollisionObjectSW *A,int p_subindex_A,CollisionObjectSW *B,int p_subindex_B,void *p_self); static void* _broadphase_pair(CollisionObjectSW *A,int p_subindex_A,CollisionObjectSW *B,int p_subindex_B,void *p_self);
static void _broadphase_unpair(CollisionObjectSW *A,int p_subindex_A,CollisionObjectSW *B,int p_subindex_B,void *p_data,void *p_self); static void _broadphase_unpair(CollisionObjectSW *A,int p_subindex_A,CollisionObjectSW *B,int p_subindex_B,void *p_data,void *p_self);
Set<CollisionObjectSW*> objects; Set<CollisionObjectSW*> objects;
AreaSW *area; AreaSW *area;
real_t contact_recycle_radius; real_t contact_recycle_radius;
real_t contact_max_separation; real_t contact_max_separation;
real_t contact_max_allowed_penetration; real_t contact_max_allowed_penetration;
real_t constraint_bias; real_t constraint_bias;
enum { enum {
INTERSECTION_QUERY_MAX=2048 INTERSECTION_QUERY_MAX=2048
}; };
CollisionObjectSW *intersection_query_results[INTERSECTION_QUERY_MAX]; CollisionObjectSW *intersection_query_results[INTERSECTION_QUERY_MAX];
int intersection_query_subindex_results[INTERSECTION_QUERY_MAX]; int intersection_query_subindex_results[INTERSECTION_QUERY_MAX];
float body_linear_velocity_sleep_threshold; float body_linear_velocity_sleep_threshold;
float body_angular_velocity_sleep_threshold; float body_angular_velocity_sleep_threshold;
float body_time_to_sleep; float body_time_to_sleep;
float body_angular_velocity_damp_ratio; float body_angular_velocity_damp_ratio;
bool locked; bool locked;
int island_count; int island_count;
int active_objects; int active_objects;
int collision_pairs; int collision_pairs;
RID static_global_body; RID static_global_body;
Vector<Vector3> contact_debug; Vector<Vector3> contact_debug;
int contact_debug_count; int contact_debug_count;
friend class PhysicsDirectSpaceStateSW; friend class PhysicsDirectSpaceStateSW;
public: public:
_FORCE_INLINE_ void set_self(const RID& p_self) { self=p_self; } _FORCE_INLINE_ void set_self(const RID& p_self) { self=p_self; }
_FORCE_INLINE_ RID get_self() const { return self; } _FORCE_INLINE_ RID get_self() const { return self; }
void set_default_area(AreaSW *p_area) { area=p_area; } void set_default_area(AreaSW *p_area) { area=p_area; }
AreaSW *get_default_area() const { return area; } AreaSW *get_default_area() const { return area; }
const SelfList<BodySW>::List& get_active_body_list() const; const SelfList<BodySW>::List& get_active_body_list() const;
void body_add_to_active_list(SelfList<BodySW>* p_body); void body_add_to_active_list(SelfList<BodySW>* p_body);
void body_remove_from_active_list(SelfList<BodySW>* p_body); void body_remove_from_active_list(SelfList<BodySW>* p_body);
void body_add_to_inertia_update_list(SelfList<BodySW>* p_body); void body_add_to_inertia_update_list(SelfList<BodySW>* p_body);
void body_remove_from_inertia_update_list(SelfList<BodySW>* p_body); void body_remove_from_inertia_update_list(SelfList<BodySW>* p_body);
void body_add_to_state_query_list(SelfList<BodySW>* p_body); void body_add_to_state_query_list(SelfList<BodySW>* p_body);
void body_remove_from_state_query_list(SelfList<BodySW>* p_body); void body_remove_from_state_query_list(SelfList<BodySW>* p_body);
void area_add_to_monitor_query_list(SelfList<AreaSW>* p_area); void area_add_to_monitor_query_list(SelfList<AreaSW>* p_area);
void area_remove_from_monitor_query_list(SelfList<AreaSW>* p_area); void area_remove_from_monitor_query_list(SelfList<AreaSW>* p_area);
void area_add_to_moved_list(SelfList<AreaSW>* p_area); void area_add_to_moved_list(SelfList<AreaSW>* p_area);
void area_remove_from_moved_list(SelfList<AreaSW>* p_area); void area_remove_from_moved_list(SelfList<AreaSW>* p_area);
const SelfList<AreaSW>::List& get_moved_area_list() const; const SelfList<AreaSW>::List& get_moved_area_list() const;
BroadPhaseSW *get_broadphase(); BroadPhaseSW *get_broadphase();
void add_object(CollisionObjectSW *p_object); void add_object(CollisionObjectSW *p_object);
void remove_object(CollisionObjectSW *p_object); void remove_object(CollisionObjectSW *p_object);
const Set<CollisionObjectSW*> &get_objects() const; const Set<CollisionObjectSW*> &get_objects() const;
_FORCE_INLINE_ real_t get_contact_recycle_radius() const { return contact_recycle_radius; } _FORCE_INLINE_ real_t get_contact_recycle_radius() const { return contact_recycle_radius; }
_FORCE_INLINE_ real_t get_contact_max_separation() const { return contact_max_separation; } _FORCE_INLINE_ real_t get_contact_max_separation() const { return contact_max_separation; }
_FORCE_INLINE_ real_t get_contact_max_allowed_penetration() const { return contact_max_allowed_penetration; } _FORCE_INLINE_ real_t get_contact_max_allowed_penetration() const { return contact_max_allowed_penetration; }
_FORCE_INLINE_ real_t get_constraint_bias() const { return constraint_bias; } _FORCE_INLINE_ real_t get_constraint_bias() const { return constraint_bias; }
_FORCE_INLINE_ real_t get_body_linear_velocity_sleep_treshold() const { return body_linear_velocity_sleep_threshold; } _FORCE_INLINE_ real_t get_body_linear_velocity_sleep_treshold() const { return body_linear_velocity_sleep_threshold; }
_FORCE_INLINE_ real_t get_body_angular_velocity_sleep_treshold() const { return body_angular_velocity_sleep_threshold; } _FORCE_INLINE_ real_t get_body_angular_velocity_sleep_treshold() const { return body_angular_velocity_sleep_threshold; }
_FORCE_INLINE_ real_t get_body_time_to_sleep() const { return body_time_to_sleep; } _FORCE_INLINE_ real_t get_body_time_to_sleep() const { return body_time_to_sleep; }
_FORCE_INLINE_ real_t get_body_angular_velocity_damp_ratio() const { return body_angular_velocity_damp_ratio; } _FORCE_INLINE_ real_t get_body_angular_velocity_damp_ratio() const { return body_angular_velocity_damp_ratio; }
void update(); void update();
void setup(); void setup();
void call_queries(); void call_queries();
bool is_locked() const; bool is_locked() const;
void lock(); void lock();
void unlock(); void unlock();
void set_param(PhysicsServer::SpaceParameter p_param, real_t p_value); void set_param(PhysicsServer::SpaceParameter p_param, real_t p_value);
real_t get_param(PhysicsServer::SpaceParameter p_param) const; real_t get_param(PhysicsServer::SpaceParameter p_param) const;
void set_island_count(int p_island_count) { island_count=p_island_count; } void set_island_count(int p_island_count) { island_count=p_island_count; }
int get_island_count() const { return island_count; } int get_island_count() const { return island_count; }
void set_active_objects(int p_active_objects) { active_objects=p_active_objects; } void set_active_objects(int p_active_objects) { active_objects=p_active_objects; }
int get_active_objects() const { return active_objects; } int get_active_objects() const { return active_objects; }
int get_collision_pairs() const { return collision_pairs; } int get_collision_pairs() const { return collision_pairs; }
PhysicsDirectSpaceStateSW *get_direct_state(); PhysicsDirectSpaceStateSW *get_direct_state();
void set_debug_contacts(int p_amount) { contact_debug.resize(p_amount); } void set_debug_contacts(int p_amount) { contact_debug.resize(p_amount); }
_FORCE_INLINE_ bool is_debugging_contacts() const { return !contact_debug.empty(); } _FORCE_INLINE_ bool is_debugging_contacts() const { return !contact_debug.empty(); }
_FORCE_INLINE_ void add_debug_contact(const Vector3& p_contact) { if (contact_debug_count<contact_debug.size()) contact_debug[contact_debug_count++]=p_contact; } _FORCE_INLINE_ void add_debug_contact(const Vector3& p_contact) { if (contact_debug_count<contact_debug.size()) contact_debug[contact_debug_count++]=p_contact; }
_FORCE_INLINE_ Vector<Vector3> get_debug_contacts() { return contact_debug; } _FORCE_INLINE_ Vector<Vector3> get_debug_contacts() { return contact_debug; }
_FORCE_INLINE_ int get_debug_contact_count() { return contact_debug_count; } _FORCE_INLINE_ int get_debug_contact_count() { return contact_debug_count; }
void set_static_global_body(RID p_body) { static_global_body=p_body; } void set_static_global_body(RID p_body) { static_global_body=p_body; }
RID get_static_global_body() { return static_global_body; } RID get_static_global_body() { return static_global_body; }
SpaceSW(); SpaceSW();
~SpaceSW(); ~SpaceSW();
}; };
#endif // SPACE__SW_H #endif // SPACE__SW_H

1194
tools/editor/plugins/path_editor_plugin.cpp
View file

File diff suppressed because it is too large Load diff

6382
tools/editor/spatial_editor_gizmos.cpp
View file

File diff suppressed because it is too large Load diff

982
tools/editor/spatial_editor_gizmos.h
View file

@ -1,491 +1,491 @@
/*************************************************************************/ /*************************************************************************/
/* spatial_editor_gizmos.h */ /* spatial_editor_gizmos.h */
/*************************************************************************/ /*************************************************************************/
/* This file is part of: */ /* This file is part of: */
/* GODOT ENGINE */ /* GODOT ENGINE */
/* http://www.godotengine.org */ /* http://www.godotengine.org */
/*************************************************************************/ /*************************************************************************/
/* Copyright (c) 2007-2015 Juan Linietsky, Ariel Manzur. */ /* Copyright (c) 2007-2015 Juan Linietsky, Ariel Manzur. */
/* */ /* */
/* Permission is hereby granted, free of charge, to any person obtaining */ /* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */ /* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */ /* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */ /* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */ /* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */ /* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */ /* the following conditions: */
/* */ /* */
/* The above copyright notice and this permission notice shall be */ /* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */ /* included in all copies or substantial portions of the Software. */
/* */ /* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/ /*************************************************************************/
#ifndef SPATIAL_EDITOR_GIZMOS_H #ifndef SPATIAL_EDITOR_GIZMOS_H
#define SPATIAL_EDITOR_GIZMOS_H #define SPATIAL_EDITOR_GIZMOS_H
#include "tools/editor/plugins/spatial_editor_plugin.h" #include "tools/editor/plugins/spatial_editor_plugin.h"
#include "scene/3d/light.h" #include "scene/3d/light.h"
#include "scene/3d/camera.h" #include "scene/3d/camera.h"
#include "scene/3d/position_3d.h" #include "scene/3d/position_3d.h"
#include "scene/3d/spatial_sample_player.h" #include "scene/3d/spatial_sample_player.h"
#include "scene/3d/spatial_stream_player.h" #include "scene/3d/spatial_stream_player.h"
#include "scene/3d/test_cube.h" #include "scene/3d/test_cube.h"
#include "scene/3d/mesh_instance.h" #include "scene/3d/mesh_instance.h"
#include "scene/3d/body_shape.h" #include "scene/3d/body_shape.h"
#include "scene/3d/room_instance.h" #include "scene/3d/room_instance.h"
#include "scene/3d/visibility_notifier.h" #include "scene/3d/visibility_notifier.h"
#include "scene/3d/portal.h" #include "scene/3d/portal.h"
#include "scene/3d/ray_cast.h" #include "scene/3d/ray_cast.h"
#include "scene/3d/navigation_mesh.h" #include "scene/3d/navigation_mesh.h"
#include "scene/3d/vehicle_body.h" #include "scene/3d/vehicle_body.h"
#include "scene/3d/collision_polygon.h" #include "scene/3d/collision_polygon.h"
#include "scene/3d/physics_joint.h" #include "scene/3d/physics_joint.h"
class Camera; class Camera;
class SpatialGizmoTool : public SpatialEditorGizmo { class SpatialGizmoTool : public SpatialEditorGizmo {
OBJ_TYPE(SpatialGizmoTool,SpatialGizmo); OBJ_TYPE(SpatialGizmoTool,SpatialGizmo);
struct Instance{ struct Instance{
RID instance; RID instance;
Ref<Mesh> mesh; Ref<Mesh> mesh;
RID skeleton; RID skeleton;
bool billboard; bool billboard;
bool unscaled; bool unscaled;
bool can_intersect; bool can_intersect;
bool extra_margin; bool extra_margin;
Instance() { Instance() {
billboard=false; billboard=false;
unscaled=false; unscaled=false;
can_intersect=false; can_intersect=false;
extra_margin=false; extra_margin=false;
} }
void create_instance(Spatial *p_base); void create_instance(Spatial *p_base);
}; };
Vector<Vector3> collision_segments; Vector<Vector3> collision_segments;
Ref<TriangleMesh> collision_mesh; Ref<TriangleMesh> collision_mesh;
struct Handle { struct Handle {
Vector3 pos; Vector3 pos;
bool billboard; bool billboard;
}; };
Vector<Vector3> handles; Vector<Vector3> handles;
Vector<Vector3> secondary_handles; Vector<Vector3> secondary_handles;
bool billboard_handle; bool billboard_handle;
bool valid; bool valid;
Spatial *base; Spatial *base;
Vector<Instance> instances; Vector<Instance> instances;
Spatial *spatial_node; Spatial *spatial_node;
protected: protected:
void add_lines(const Vector<Vector3> &p_lines,const Ref<Material>& p_material,bool p_billboard=false); void add_lines(const Vector<Vector3> &p_lines,const Ref<Material>& p_material,bool p_billboard=false);
void add_mesh(const Ref<Mesh>& p_mesh,bool p_billboard=false,const RID& p_skeleton=RID()); void add_mesh(const Ref<Mesh>& p_mesh,bool p_billboard=false,const RID& p_skeleton=RID());
void add_collision_segments(const Vector<Vector3> &p_lines); void add_collision_segments(const Vector<Vector3> &p_lines);
void add_collision_triangles(const Ref<TriangleMesh>& p_tmesh); void add_collision_triangles(const Ref<TriangleMesh>& p_tmesh);
void add_unscaled_billboard(const Ref<Material>& p_material,float p_scale=1); void add_unscaled_billboard(const Ref<Material>& p_material,float p_scale=1);
void add_handles(const Vector<Vector3> &p_handles,bool p_billboard=false,bool p_secondary=false); void add_handles(const Vector<Vector3> &p_handles,bool p_billboard=false,bool p_secondary=false);
void set_spatial_node(Spatial *p_node); void set_spatial_node(Spatial *p_node);
public: public:
virtual Vector3 get_handle_pos(int p_idx) const; virtual Vector3 get_handle_pos(int p_idx) const;
virtual bool intersect_frustum(const Camera *p_camera,const Vector<Plane> &p_frustum); virtual bool intersect_frustum(const Camera *p_camera,const Vector<Plane> &p_frustum);
virtual bool intersect_ray(const Camera *p_camera,const Point2& p_point, Vector3& r_pos, Vector3& r_normal,int *r_gizmo_handle=NULL,bool p_sec_first=false); virtual bool intersect_ray(const Camera *p_camera,const Point2& p_point, Vector3& r_pos, Vector3& r_normal,int *r_gizmo_handle=NULL,bool p_sec_first=false);
void clear(); void clear();
void create(); void create();
void transform(); void transform();
//void redraw(); //void redraw();
void free(); void free();
SpatialGizmoTool(); SpatialGizmoTool();
~SpatialGizmoTool(); ~SpatialGizmoTool();
}; };
class LightSpatialGizmo : public SpatialGizmoTool { class LightSpatialGizmo : public SpatialGizmoTool {
OBJ_TYPE(LightSpatialGizmo,SpatialGizmoTool); OBJ_TYPE(LightSpatialGizmo,SpatialGizmoTool);
Light* light; Light* light;
public: public:
virtual String get_handle_name(int p_idx) const; virtual String get_handle_name(int p_idx) const;
virtual Variant get_handle_value(int p_idx) const; virtual Variant get_handle_value(int p_idx) const;
virtual void set_handle(int p_idx,Camera *p_camera, const Point2& p_point); virtual void set_handle(int p_idx,Camera *p_camera, const Point2& p_point);
virtual void commit_handle(int p_idx,const Variant& p_restore,bool p_cancel=false); virtual void commit_handle(int p_idx,const Variant& p_restore,bool p_cancel=false);
void redraw(); void redraw();
LightSpatialGizmo(Light* p_light=NULL); LightSpatialGizmo(Light* p_light=NULL);
}; };
class CameraSpatialGizmo : public SpatialGizmoTool { class CameraSpatialGizmo : public SpatialGizmoTool {
OBJ_TYPE(CameraSpatialGizmo,SpatialGizmoTool); OBJ_TYPE(CameraSpatialGizmo,SpatialGizmoTool);
Camera* camera; Camera* camera;
public: public:
virtual String get_handle_name(int p_idx) const; virtual String get_handle_name(int p_idx) const;
virtual Variant get_handle_value(int p_idx) const; virtual Variant get_handle_value(int p_idx) const;
virtual void set_handle(int p_idx,Camera *p_camera, const Point2& p_point); virtual void set_handle(int p_idx,Camera *p_camera, const Point2& p_point);
virtual void commit_handle(int p_idx,const Variant& p_restore,bool p_cancel=false); virtual void commit_handle(int p_idx,const Variant& p_restore,bool p_cancel=false);
void redraw(); void redraw();
CameraSpatialGizmo(Camera* p_camera=NULL); CameraSpatialGizmo(Camera* p_camera=NULL);
}; };
class MeshInstanceSpatialGizmo : public SpatialGizmoTool { class MeshInstanceSpatialGizmo : public SpatialGizmoTool {
OBJ_TYPE(MeshInstanceSpatialGizmo,SpatialGizmoTool); OBJ_TYPE(MeshInstanceSpatialGizmo,SpatialGizmoTool);
MeshInstance* mesh; MeshInstance* mesh;
public: public:
void redraw(); void redraw();
MeshInstanceSpatialGizmo(MeshInstance* p_mesh=NULL); MeshInstanceSpatialGizmo(MeshInstance* p_mesh=NULL);
}; };
class Position3DSpatialGizmo : public SpatialGizmoTool { class Position3DSpatialGizmo : public SpatialGizmoTool {
OBJ_TYPE(Position3DSpatialGizmo,SpatialGizmoTool); OBJ_TYPE(Position3DSpatialGizmo,SpatialGizmoTool);
Position3D* p3d; Position3D* p3d;
public: public:
void redraw(); void redraw();
Position3DSpatialGizmo(Position3D* p_p3d=NULL); Position3DSpatialGizmo(Position3D* p_p3d=NULL);
}; };
class SkeletonSpatialGizmo : public SpatialGizmoTool { class SkeletonSpatialGizmo : public SpatialGizmoTool {
OBJ_TYPE(SkeletonSpatialGizmo,SpatialGizmoTool); OBJ_TYPE(SkeletonSpatialGizmo,SpatialGizmoTool);
Skeleton* skel; Skeleton* skel;
public: public:
void redraw(); void redraw();
SkeletonSpatialGizmo(Skeleton* p_skel=NULL); SkeletonSpatialGizmo(Skeleton* p_skel=NULL);
}; };
class SpatialPlayerSpatialGizmo : public SpatialGizmoTool { class SpatialPlayerSpatialGizmo : public SpatialGizmoTool {
OBJ_TYPE(SpatialPlayerSpatialGizmo,SpatialGizmoTool); OBJ_TYPE(SpatialPlayerSpatialGizmo,SpatialGizmoTool);
SpatialPlayer* splayer; SpatialPlayer* splayer;
public: public:
void redraw(); void redraw();
SpatialPlayerSpatialGizmo(SpatialPlayer* p_splayer=NULL); SpatialPlayerSpatialGizmo(SpatialPlayer* p_splayer=NULL);
}; };
class TestCubeSpatialGizmo : public SpatialGizmoTool { class TestCubeSpatialGizmo : public SpatialGizmoTool {
OBJ_TYPE(TestCubeSpatialGizmo,SpatialGizmoTool); OBJ_TYPE(TestCubeSpatialGizmo,SpatialGizmoTool);
TestCube* tc; TestCube* tc;
public: public:
void redraw(); void redraw();
TestCubeSpatialGizmo(TestCube* p_tc=NULL); TestCubeSpatialGizmo(TestCube* p_tc=NULL);
}; };
class RoomSpatialGizmo : public SpatialGizmoTool { class RoomSpatialGizmo : public SpatialGizmoTool {
OBJ_TYPE(RoomSpatialGizmo,SpatialGizmoTool); OBJ_TYPE(RoomSpatialGizmo,SpatialGizmoTool);
struct _EdgeKey { struct _EdgeKey {
Vector3 from; Vector3 from;
Vector3 to; Vector3 to;
bool operator<(const _EdgeKey& p_with) const { return from==p_with.from ? to < p_with.to : from < p_with.from; } bool operator<(const _EdgeKey& p_with) const { return from==p_with.from ? to < p_with.to : from < p_with.from; }
}; };
Room* room; Room* room;
public: public:
void redraw(); void redraw();
RoomSpatialGizmo(Room* p_room=NULL); RoomSpatialGizmo(Room* p_room=NULL);
}; };
class PortalSpatialGizmo : public SpatialGizmoTool { class PortalSpatialGizmo : public SpatialGizmoTool {
OBJ_TYPE(PortalSpatialGizmo,SpatialGizmoTool); OBJ_TYPE(PortalSpatialGizmo,SpatialGizmoTool);
Portal* portal; Portal* portal;
public: public:
void redraw(); void redraw();
PortalSpatialGizmo(Portal* p_portal=NULL); PortalSpatialGizmo(Portal* p_portal=NULL);
}; };
class VisibilityNotifierGizmo : public SpatialGizmoTool { class VisibilityNotifierGizmo : public SpatialGizmoTool {
OBJ_TYPE(VisibilityNotifierGizmo ,SpatialGizmoTool); OBJ_TYPE(VisibilityNotifierGizmo ,SpatialGizmoTool);
VisibilityNotifier* notifier; VisibilityNotifier* notifier;
public: public:
virtual String get_handle_name(int p_idx) const; virtual String get_handle_name(int p_idx) const;
virtual Variant get_handle_value(int p_idx) const; virtual Variant get_handle_value(int p_idx) const;
virtual void set_handle(int p_idx,Camera *p_camera, const Point2& p_point); virtual void set_handle(int p_idx,Camera *p_camera, const Point2& p_point);
virtual void commit_handle(int p_idx,const Variant& p_restore,bool p_cancel=false); virtual void commit_handle(int p_idx,const Variant& p_restore,bool p_cancel=false);
void redraw(); void redraw();
VisibilityNotifierGizmo(VisibilityNotifier* p_notifier=NULL); VisibilityNotifierGizmo(VisibilityNotifier* p_notifier=NULL);
}; };
class CollisionShapeSpatialGizmo : public SpatialGizmoTool { class CollisionShapeSpatialGizmo : public SpatialGizmoTool {
OBJ_TYPE(CollisionShapeSpatialGizmo,SpatialGizmoTool); OBJ_TYPE(CollisionShapeSpatialGizmo,SpatialGizmoTool);
CollisionShape* cs; CollisionShape* cs;
public: public:
virtual String get_handle_name(int p_idx) const; virtual String get_handle_name(int p_idx) const;
virtual Variant get_handle_value(int p_idx) const; virtual Variant get_handle_value(int p_idx) const;
virtual void set_handle(int p_idx,Camera *p_camera, const Point2& p_point); virtual void set_handle(int p_idx,Camera *p_camera, const Point2& p_point);
virtual void commit_handle(int p_idx,const Variant& p_restore,bool p_cancel=false); virtual void commit_handle(int p_idx,const Variant& p_restore,bool p_cancel=false);
void redraw(); void redraw();
CollisionShapeSpatialGizmo(CollisionShape* p_cs=NULL); CollisionShapeSpatialGizmo(CollisionShape* p_cs=NULL);
}; };
class CollisionPolygonSpatialGizmo : public SpatialGizmoTool { class CollisionPolygonSpatialGizmo : public SpatialGizmoTool {
OBJ_TYPE(CollisionPolygonSpatialGizmo,SpatialGizmoTool); OBJ_TYPE(CollisionPolygonSpatialGizmo,SpatialGizmoTool);
CollisionPolygon* polygon; CollisionPolygon* polygon;
public: public:
void redraw(); void redraw();
CollisionPolygonSpatialGizmo(CollisionPolygon* p_polygon=NULL); CollisionPolygonSpatialGizmo(CollisionPolygon* p_polygon=NULL);
}; };
class RayCastSpatialGizmo : public SpatialGizmoTool { class RayCastSpatialGizmo : public SpatialGizmoTool {
OBJ_TYPE(RayCastSpatialGizmo,SpatialGizmoTool); OBJ_TYPE(RayCastSpatialGizmo,SpatialGizmoTool);
RayCast* raycast; RayCast* raycast;
public: public:
void redraw(); void redraw();
RayCastSpatialGizmo(RayCast* p_raycast=NULL); RayCastSpatialGizmo(RayCast* p_raycast=NULL);
}; };
class VehicleWheelSpatialGizmo : public SpatialGizmoTool { class VehicleWheelSpatialGizmo : public SpatialGizmoTool {
OBJ_TYPE(VehicleWheelSpatialGizmo,SpatialGizmoTool); OBJ_TYPE(VehicleWheelSpatialGizmo,SpatialGizmoTool);
VehicleWheel* car_wheel; VehicleWheel* car_wheel;
public: public:
void redraw(); void redraw();
VehicleWheelSpatialGizmo(VehicleWheel* p_car_wheel=NULL); VehicleWheelSpatialGizmo(VehicleWheel* p_car_wheel=NULL);
}; };
class NavigationMeshSpatialGizmo : public SpatialGizmoTool { class NavigationMeshSpatialGizmo : public SpatialGizmoTool {
OBJ_TYPE(NavigationMeshSpatialGizmo,SpatialGizmoTool); OBJ_TYPE(NavigationMeshSpatialGizmo,SpatialGizmoTool);
struct _EdgeKey { struct _EdgeKey {
Vector3 from; Vector3 from;
Vector3 to; Vector3 to;
bool operator<(const _EdgeKey& p_with) const { return from==p_with.from ? to < p_with.to : from < p_with.from; } bool operator<(const _EdgeKey& p_with) const { return from==p_with.from ? to < p_with.to : from < p_with.from; }
}; };
NavigationMeshInstance* navmesh; NavigationMeshInstance* navmesh;
public: public:
void redraw(); void redraw();
NavigationMeshSpatialGizmo(NavigationMeshInstance* p_navmesh=NULL); NavigationMeshSpatialGizmo(NavigationMeshInstance* p_navmesh=NULL);
}; };
class PinJointSpatialGizmo : public SpatialGizmoTool { class PinJointSpatialGizmo : public SpatialGizmoTool {
OBJ_TYPE(PinJointSpatialGizmo,SpatialGizmoTool); OBJ_TYPE(PinJointSpatialGizmo,SpatialGizmoTool);
PinJoint* p3d; PinJoint* p3d;
public: public:
void redraw(); void redraw();
PinJointSpatialGizmo(PinJoint* p_p3d=NULL); PinJointSpatialGizmo(PinJoint* p_p3d=NULL);
}; };
class HingeJointSpatialGizmo : public SpatialGizmoTool { class HingeJointSpatialGizmo : public SpatialGizmoTool {
OBJ_TYPE(HingeJointSpatialGizmo,SpatialGizmoTool); OBJ_TYPE(HingeJointSpatialGizmo,SpatialGizmoTool);
HingeJoint* p3d; HingeJoint* p3d;
public: public:
void redraw(); void redraw();
HingeJointSpatialGizmo(HingeJoint* p_p3d=NULL); HingeJointSpatialGizmo(HingeJoint* p_p3d=NULL);
}; };
class SliderJointSpatialGizmo : public SpatialGizmoTool { class SliderJointSpatialGizmo : public SpatialGizmoTool {
OBJ_TYPE(SliderJointSpatialGizmo,SpatialGizmoTool); OBJ_TYPE(SliderJointSpatialGizmo,SpatialGizmoTool);
SliderJoint* p3d; SliderJoint* p3d;
public: public:
void redraw(); void redraw();
SliderJointSpatialGizmo(SliderJoint* p_p3d=NULL); SliderJointSpatialGizmo(SliderJoint* p_p3d=NULL);
}; };
class ConeTwistJointSpatialGizmo : public SpatialGizmoTool { class ConeTwistJointSpatialGizmo : public SpatialGizmoTool {
OBJ_TYPE(ConeTwistJointSpatialGizmo,SpatialGizmoTool); OBJ_TYPE(ConeTwistJointSpatialGizmo,SpatialGizmoTool);
ConeTwistJoint* p3d; ConeTwistJoint* p3d;
public: public:
void redraw(); void redraw();
ConeTwistJointSpatialGizmo(ConeTwistJoint* p_p3d=NULL); ConeTwistJointSpatialGizmo(ConeTwistJoint* p_p3d=NULL);
}; };
class Generic6DOFJointSpatialGizmo : public SpatialGizmoTool { class Generic6DOFJointSpatialGizmo : public SpatialGizmoTool {
OBJ_TYPE(Generic6DOFJointSpatialGizmo,SpatialGizmoTool); OBJ_TYPE(Generic6DOFJointSpatialGizmo,SpatialGizmoTool);
Generic6DOFJoint* p3d; Generic6DOFJoint* p3d;
public: public:
void redraw(); void redraw();
Generic6DOFJointSpatialGizmo(Generic6DOFJoint* p_p3d=NULL); Generic6DOFJointSpatialGizmo(Generic6DOFJoint* p_p3d=NULL);
}; };
class SpatialEditorGizmos { class SpatialEditorGizmos {
public: public:
Ref<FixedMaterial> create_line_material(const Color& p_base_color); Ref<FixedMaterial> create_line_material(const Color& p_base_color);
Ref<FixedMaterial> create_solid_material(const Color& p_base_color); Ref<FixedMaterial> create_solid_material(const Color& p_base_color);
Ref<FixedMaterial> handle2_material; Ref<FixedMaterial> handle2_material;
Ref<FixedMaterial> handle_material; Ref<FixedMaterial> handle_material;
Ref<FixedMaterial> light_material; Ref<FixedMaterial> light_material;
Ref<FixedMaterial> light_material_omni_icon; Ref<FixedMaterial> light_material_omni_icon;
Ref<FixedMaterial> light_material_directional_icon; Ref<FixedMaterial> light_material_directional_icon;
Ref<FixedMaterial> camera_material; Ref<FixedMaterial> camera_material;
Ref<FixedMaterial> skeleton_material; Ref<FixedMaterial> skeleton_material;
Ref<FixedMaterial> room_material; Ref<FixedMaterial> room_material;
Ref<FixedMaterial> portal_material; Ref<FixedMaterial> portal_material;
Ref<FixedMaterial> raycast_material; Ref<FixedMaterial> raycast_material;
Ref<FixedMaterial> visibility_notifier_material; Ref<FixedMaterial> visibility_notifier_material;
Ref<FixedMaterial> car_wheel_material; Ref<FixedMaterial> car_wheel_material;
Ref<FixedMaterial> joint_material; Ref<FixedMaterial> joint_material;
Ref<FixedMaterial> navmesh_edge_material; Ref<FixedMaterial> navmesh_edge_material;
Ref<FixedMaterial> navmesh_solid_material; Ref<FixedMaterial> navmesh_solid_material;
Ref<FixedMaterial> navmesh_edge_material_disabled; Ref<FixedMaterial> navmesh_edge_material_disabled;
Ref<FixedMaterial> navmesh_solid_material_disabled; Ref<FixedMaterial> navmesh_solid_material_disabled;
Ref<FixedMaterial> sample_player_icon; Ref<FixedMaterial> sample_player_icon;
Ref<FixedMaterial> stream_player_icon; Ref<FixedMaterial> stream_player_icon;
Ref<FixedMaterial> visibility_notifier_icon; Ref<FixedMaterial> visibility_notifier_icon;
Ref<FixedMaterial> shape_material; Ref<FixedMaterial> shape_material;
Ref<Texture> handle_t; Ref<Texture> handle_t;
Ref<Mesh> pos3d_mesh; Ref<Mesh> pos3d_mesh;
static SpatialEditorGizmos *singleton; static SpatialEditorGizmos *singleton;
Ref<TriangleMesh> test_cube_tm; Ref<TriangleMesh> test_cube_tm;
Ref<SpatialEditorGizmo> get_gizmo(Spatial *p_spatial); Ref<SpatialEditorGizmo> get_gizmo(Spatial *p_spatial);
SpatialEditorGizmos(); SpatialEditorGizmos();
}; };
#endif // SPATIAL_EDITOR_GIZMOS_H #endif // SPATIAL_EDITOR_GIZMOS_H

948
tools/export/blender25/godot_export_manager.py
View file

@ -1,474 +1,474 @@
# ##### BEGIN GPL LICENSE BLOCK ##### # ##### BEGIN GPL LICENSE BLOCK #####
# #
# This program is free software; you can redistribute it and/or # This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License # modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2 # as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version. # of the License, or (at your option) any later version.
# #
# This program is distributed in the hope that it will be useful, # This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of # but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details. # GNU General Public License for more details.
# #
# You should have received a copy of the GNU General Public License # You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software Foundation, # along with this program; if not, write to the Free Software Foundation,
# Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. # Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
# #
# ##### END GPL LICENSE BLOCK ##### # ##### END GPL LICENSE BLOCK #####
# Script copyright (c) Andreas Esau # Script copyright (c) Andreas Esau
bl_info = { bl_info = {
"name": "Godot Export Manager", "name": "Godot Export Manager",
"author": "Andreas Esau", "author": "Andreas Esau",
"version": (1, 0), "version": (1, 0),
"blender": (2, 7, 0), "blender": (2, 7, 0),
"location": "Scene Properties > Godot Export Manager", "location": "Scene Properties > Godot Export Manager",
"description": "Godot Export Manager uses the Better Collada Exporter to manage Export Groups and automatically export the objects groups to Collada Files.", "description": "Godot Export Manager uses the Better Collada Exporter to manage Export Groups and automatically export the objects groups to Collada Files.",
"warning": "", "warning": "",
"wiki_url": ("http://www.godotengine.org"), "wiki_url": ("http://www.godotengine.org"),
"tracker_url": "", "tracker_url": "",
"category": "Import-Export"} "category": "Import-Export"}
import bpy import bpy
from bpy.props import StringProperty, BoolProperty, EnumProperty, FloatProperty, FloatVectorProperty, IntProperty, CollectionProperty, PointerProperty from bpy.props import StringProperty, BoolProperty, EnumProperty, FloatProperty, FloatVectorProperty, IntProperty, CollectionProperty, PointerProperty
import os import os
from bpy.app.handlers import persistent from bpy.app.handlers import persistent
from mathutils import Vector, Matrix from mathutils import Vector, Matrix
class godot_export_manager(bpy.types.Panel): class godot_export_manager(bpy.types.Panel):
bl_label = "Godot Export Manager" bl_label = "Godot Export Manager"
bl_space_type = 'PROPERTIES' bl_space_type = 'PROPERTIES'
bl_region_type = 'WINDOW' bl_region_type = 'WINDOW'
bl_context = "scene" bl_context = "scene"
bpy.types.Scene.godot_export_on_save = BoolProperty(default=False) bpy.types.Scene.godot_export_on_save = BoolProperty(default=False)
### draw function for all ui elements ### draw function for all ui elements
def draw(self, context): def draw(self, context):
layout = self.layout layout = self.layout
split = self.layout.split() split = self.layout.split()
scene = bpy.data.scenes[0] scene = bpy.data.scenes[0]
ob = context.object ob = context.object
scene = context.scene scene = context.scene
row = layout.row() row = layout.row()
col = row.column() col = row.column()
col.prop(scene,"godot_export_on_save",text="Export Groups on save") col.prop(scene,"godot_export_on_save",text="Export Groups on save")
row = layout.row() row = layout.row()
col = row.column(align=True) col = row.column(align=True)
op = col.operator("scene.godot_add_objects_to_group",text="Add selected objects to Group",icon="COPYDOWN") op = col.operator("scene.godot_add_objects_to_group",text="Add selected objects to Group",icon="COPYDOWN")
op = col.operator("scene.godot_delete_objects_from_group",text="Delete selected objects from Group",icon="PASTEDOWN") op = col.operator("scene.godot_delete_objects_from_group",text="Delete selected objects from Group",icon="PASTEDOWN")
row = layout.row() row = layout.row()
col = row.column() col = row.column()
col.label(text="Export Groups:") col.label(text="Export Groups:")
row = layout.row() row = layout.row()
col = row.column() col = row.column()
col.template_list("UI_List_Godot","dummy",scene, "godot_export_groups", scene, "godot_export_groups_index",rows=1,maxrows=10,type='DEFAULT') col.template_list("UI_List_Godot","dummy",scene, "godot_export_groups", scene, "godot_export_groups_index",rows=1,maxrows=10,type='DEFAULT')
col = row.column(align=True) col = row.column(align=True)
col.operator("scene.godot_add_export_group",text="",icon="ZOOMIN") col.operator("scene.godot_add_export_group",text="",icon="ZOOMIN")
col.operator("scene.godot_delete_export_group",text="",icon="ZOOMOUT") col.operator("scene.godot_delete_export_group",text="",icon="ZOOMOUT")
col.operator("scene.godot_export_all_groups",text="",icon="EXPORT") col.operator("scene.godot_export_all_groups",text="",icon="EXPORT")
if len(scene.godot_export_groups) > 0: if len(scene.godot_export_groups) > 0:
row = layout.row() row = layout.row()
col = row.column() col = row.column()
group = scene.godot_export_groups[scene.godot_export_groups_index] group = scene.godot_export_groups[scene.godot_export_groups_index]
col.prop(group,"name",text="Group Name") col.prop(group,"name",text="Group Name")
col.prop(group,"export_name",text="Export Name") col.prop(group,"export_name",text="Export Name")
col.prop(group,"export_path",text="Export Filepath") col.prop(group,"export_path",text="Export Filepath")
row = layout.row() row = layout.row()
col = row.column() col = row.column()
row = layout.row() row = layout.row()
col = row.column() col = row.column()
col.label(text="Export Settings:") col.label(text="Export Settings:")
col = col.row(align=True) col = col.row(align=True)
col.prop(group,"apply_loc",toggle=True,icon="MAN_TRANS") col.prop(group,"apply_loc",toggle=True,icon="MAN_TRANS")
col.prop(group,"apply_rot",toggle=True,icon="MAN_ROT") col.prop(group,"apply_rot",toggle=True,icon="MAN_ROT")
col.prop(group,"apply_scale",toggle=True,icon="MAN_SCALE") col.prop(group,"apply_scale",toggle=True,icon="MAN_SCALE")
row = layout.row() row = layout.row()
col = row.column() col = row.column()
col.prop(group,"use_include_particle_duplicates") col.prop(group,"use_include_particle_duplicates")
col.prop(group,"use_mesh_modifiers") col.prop(group,"use_mesh_modifiers")
col.prop(group,"use_tangent_arrays") col.prop(group,"use_tangent_arrays")
col.prop(group,"use_triangles") col.prop(group,"use_triangles")
col.prop(group,"use_copy_images") col.prop(group,"use_copy_images")
col.prop(group,"use_active_layers") col.prop(group,"use_active_layers")
col.prop(group,"use_exclude_ctrl_bones") col.prop(group,"use_exclude_ctrl_bones")
col.prop(group,"use_anim") col.prop(group,"use_anim")
col.prop(group,"use_anim_action_all") col.prop(group,"use_anim_action_all")
col.prop(group,"use_anim_skip_noexp") col.prop(group,"use_anim_skip_noexp")
col.prop(group,"use_anim_optimize") col.prop(group,"use_anim_optimize")
col.prop(group,"anim_optimize_precision") col.prop(group,"anim_optimize_precision")
col.prop(group,"use_metadata") col.prop(group,"use_metadata")
### Custom template_list look ### Custom template_list look
class UI_List_Godot(bpy.types.UIList): class UI_List_Godot(bpy.types.UIList):
def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index): def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
ob = data ob = data
slot = item slot = item
col = layout.row(align=True) col = layout.row(align=True)
col.label(text=item.name,icon="GROUP") col.label(text=item.name,icon="GROUP")
col.prop(item,"active",text="") col.prop(item,"active",text="")
op = col.operator("scene.godot_select_group_objects",text="",emboss=False,icon="RESTRICT_SELECT_OFF") op = col.operator("scene.godot_select_group_objects",text="",emboss=False,icon="RESTRICT_SELECT_OFF")
op.idx = index op.idx = index
op = col.operator("scene.godot_export_group",text="",emboss=False,icon="EXPORT") op = col.operator("scene.godot_export_group",text="",emboss=False,icon="EXPORT")
op.idx = index op.idx = index
class add_objects_to_group(bpy.types.Operator): class add_objects_to_group(bpy.types.Operator):
bl_idname = "scene.godot_add_objects_to_group" bl_idname = "scene.godot_add_objects_to_group"
bl_label = "Add Objects to Group" bl_label = "Add Objects to Group"
bl_description = "Adds the selected Objects to the active group below." bl_description = "Adds the selected Objects to the active group below."
undo = BoolProperty(default=True) undo = BoolProperty(default=True)
def execute(self,context): def execute(self,context):
scene = context.scene scene = context.scene
objects_str = "" objects_str = ""
if len(scene.godot_export_groups) > 0: if len(scene.godot_export_groups) > 0:
for i,object in enumerate(context.selected_objects): for i,object in enumerate(context.selected_objects):
if object.name not in scene.godot_export_groups[scene.godot_export_groups_index].nodes: if object.name not in scene.godot_export_groups[scene.godot_export_groups_index].nodes:
node = scene.godot_export_groups[scene.godot_export_groups_index].nodes.add() node = scene.godot_export_groups[scene.godot_export_groups_index].nodes.add()
node.name = object.name node.name = object.name
if i == 0: if i == 0:
objects_str += object.name objects_str += object.name
else: else:
objects_str += ", "+object.name objects_str += ", "+object.name
self.report({'INFO'}, objects_str + " added to group." ) self.report({'INFO'}, objects_str + " added to group." )
if self.undo: if self.undo:
bpy.ops.ed.undo_push(message="Objects added to group") bpy.ops.ed.undo_push(message="Objects added to group")
else: else:
self.report({'WARNING'}, "Create a group first." ) self.report({'WARNING'}, "Create a group first." )
return{'FINISHED'} return{'FINISHED'}
class del_objects_from_group(bpy.types.Operator): class del_objects_from_group(bpy.types.Operator):
bl_idname = "scene.godot_delete_objects_from_group" bl_idname = "scene.godot_delete_objects_from_group"
bl_label = "Delete Objects from Group" bl_label = "Delete Objects from Group"
bl_description = "Delets the selected Objects from the active group below." bl_description = "Delets the selected Objects from the active group below."
def execute(self,context): def execute(self,context):
scene = context.scene scene = context.scene
if len(scene.godot_export_groups) > 0: if len(scene.godot_export_groups) > 0:
selected_objects = [] selected_objects = []
for object in context.selected_objects: for object in context.selected_objects:
selected_objects.append(object.name) selected_objects.append(object.name)
objects_str = "" objects_str = ""
j = 0 j = 0
for i,node in enumerate(scene.godot_export_groups[scene.godot_export_groups_index].nodes): for i,node in enumerate(scene.godot_export_groups[scene.godot_export_groups_index].nodes):
if node.name in selected_objects: if node.name in selected_objects:
scene.godot_export_groups[scene.godot_export_groups_index].nodes.remove(i) scene.godot_export_groups[scene.godot_export_groups_index].nodes.remove(i)
if j == 0: if j == 0:
objects_str += object.name objects_str += object.name
else: else:
objects_str += ", "+object.name objects_str += ", "+object.name
j+=1 j+=1
self.report({'INFO'}, objects_str + " deleted from group." ) self.report({'INFO'}, objects_str + " deleted from group." )
bpy.ops.ed.undo_push(message="Objects deleted from group") bpy.ops.ed.undo_push(message="Objects deleted from group")
else: else:
self.report({'WARNING'}, "There is no group to delete from." ) self.report({'WARNING'}, "There is no group to delete from." )
return{'FINISHED'} return{'FINISHED'}
class select_group_objects(bpy.types.Operator): class select_group_objects(bpy.types.Operator):
bl_idname = "scene.godot_select_group_objects" bl_idname = "scene.godot_select_group_objects"
bl_label = "Select Group Objects" bl_label = "Select Group Objects"
bl_description = "Will select all group Objects in the scene." bl_description = "Will select all group Objects in the scene."
idx = IntProperty() idx = IntProperty()
def execute(self,context): def execute(self,context):
scene = context.scene scene = context.scene
for object in context.scene.objects: for object in context.scene.objects:
object.select = False object.select = False
for node in scene.godot_export_groups[self.idx].nodes: for node in scene.godot_export_groups[self.idx].nodes:
if node.name in bpy.data.objects: if node.name in bpy.data.objects:
bpy.data.objects[node.name].select = True bpy.data.objects[node.name].select = True
context.scene.objects.active = bpy.data.objects[node.name] context.scene.objects.active = bpy.data.objects[node.name]
return{'FINISHED'} return{'FINISHED'}
class export_groups_autosave(bpy.types.Operator): class export_groups_autosave(bpy.types.Operator):
bl_idname = "scene.godot_export_groups_autosave" bl_idname = "scene.godot_export_groups_autosave"
bl_label = "Export All Groups" bl_label = "Export All Groups"
bl_description = "Exports all groups to Collada." bl_description = "Exports all groups to Collada."
def execute(self,context): def execute(self,context):
scene = context.scene scene = context.scene
if scene.godot_export_on_save: if scene.godot_export_on_save:
for i in range(len(scene.godot_export_groups)): for i in range(len(scene.godot_export_groups)):
if scene.godot_export_groups[i].active: if scene.godot_export_groups[i].active:
bpy.ops.scene.godot_export_group(idx=i) bpy.ops.scene.godot_export_group(idx=i)
self.report({'INFO'}, "All Groups exported." ) self.report({'INFO'}, "All Groups exported." )
bpy.ops.ed.undo_push(message="Export all Groups") bpy.ops.ed.undo_push(message="Export all Groups")
return{'FINISHED'} return{'FINISHED'}
class export_all_groups(bpy.types.Operator): class export_all_groups(bpy.types.Operator):
bl_idname = "scene.godot_export_all_groups" bl_idname = "scene.godot_export_all_groups"
bl_label = "Export All Groups" bl_label = "Export All Groups"
bl_description = "Exports all groups to Collada." bl_description = "Exports all groups to Collada."
def execute(self,context): def execute(self,context):
scene = context.scene scene = context.scene
for i in range(0,len(scene.godot_export_groups)): for i in range(0,len(scene.godot_export_groups)):
bpy.ops.scene.godot_export_group(idx=i,export_all=True) bpy.ops.scene.godot_export_group(idx=i,export_all=True)
self.report({'INFO'}, "All Groups exported." ) self.report({'INFO'}, "All Groups exported." )
return{'FINISHED'} return{'FINISHED'}
class export_group(bpy.types.Operator): class export_group(bpy.types.Operator):
bl_idname = "scene.godot_export_group" bl_idname = "scene.godot_export_group"
bl_label = "Export Group" bl_label = "Export Group"
bl_description = "Exports the active group to destination folder as Collada file." bl_description = "Exports the active group to destination folder as Collada file."
idx = IntProperty(default=0) idx = IntProperty(default=0)
export_all = BoolProperty(default=False) export_all = BoolProperty(default=False)
def copy_object_recursive(self,ob,parent,single_user = True): def copy_object_recursive(self,ob,parent,single_user = True):
new_ob = bpy.data.objects[ob.name].copy() new_ob = bpy.data.objects[ob.name].copy()
if single_user or ob.type=="ARMATURE": if single_user or ob.type=="ARMATURE":
new_mesh_data = new_ob.data.copy() new_mesh_data = new_ob.data.copy()
new_ob.data = new_mesh_data new_ob.data = new_mesh_data
bpy.context.scene.objects.link(new_ob) bpy.context.scene.objects.link(new_ob)
if ob != parent: if ob != parent:
new_ob.parent = parent new_ob.parent = parent
else: else:
new_ob.parent = None new_ob.parent = None
for child in ob.children: for child in ob.children:
self.copy_object_recursive(child,new_ob,single_user) self.copy_object_recursive(child,new_ob,single_user)
new_ob.select = True new_ob.select = True
return new_ob return new_ob
def delete_object(self,ob): def delete_object(self,ob):
if ob != None: if ob != None:
for child in ob.children: for child in ob.children:
self.delete_object(child) self.delete_object(child)
bpy.context.scene.objects.unlink(ob) bpy.context.scene.objects.unlink(ob)
bpy.data.objects.remove(ob) bpy.data.objects.remove(ob)
def convert_group_to_node(self,group): def convert_group_to_node(self,group):
if group.dupli_group != None: if group.dupli_group != None:
for object in group.dupli_group.objects: for object in group.dupli_group.objects:
if object.parent == None: if object.parent == None:
object = self.copy_object_recursive(object,object,True) object = self.copy_object_recursive(object,object,True)
matrix = Matrix(object.matrix_local) matrix = Matrix(object.matrix_local)
object.matrix_local = Matrix() object.matrix_local = Matrix()
object.matrix_local *= group.matrix_local object.matrix_local *= group.matrix_local
object.matrix_local *= matrix object.matrix_local *= matrix
self.delete_object(group) self.delete_object(group)
def execute(self,context): def execute(self,context):
scene = context.scene scene = context.scene
group = context.scene.godot_export_groups group = context.scene.godot_export_groups
if not group[self.idx].active and self.export_all: if not group[self.idx].active and self.export_all:
return{'FINISHED'} return{'FINISHED'}
for i,object in enumerate(group[self.idx].nodes): for i,object in enumerate(group[self.idx].nodes):
if object.name in bpy.data.objects: if object.name in bpy.data.objects:
pass pass
else: else:
group[self.idx].nodes.remove(i) group[self.idx].nodes.remove(i)
bpy.ops.ed.undo_push(message="Clear not existent Group Nodes.") bpy.ops.ed.undo_push(message="Clear not existent Group Nodes.")
path = group[self.idx].export_path path = group[self.idx].export_path
if (path.find("//")==0 or path.find("\\\\")==0): if (path.find("//")==0 or path.find("\\\\")==0):
#if relative, convert to absolute #if relative, convert to absolute
path = bpy.path.abspath(path) path = bpy.path.abspath(path)
path = path.replace("\\","/") path = path.replace("\\","/")
### if path exists and group export name is set the group will be exported ### if path exists and group export name is set the group will be exported
if os.path.exists(path) and group[self.idx].export_name != "": if os.path.exists(path) and group[self.idx].export_name != "":
context.scene.layers = [True,True,True,True,True,True,True,True,True,True,True,True,True,True,True,True,True,True,True,True] context.scene.layers = [True,True,True,True,True,True,True,True,True,True,True,True,True,True,True,True,True,True,True,True]
if group[self.idx].export_name.endswith(".dae"): if group[self.idx].export_name.endswith(".dae"):
path = os.path.join(path,group[self.idx].export_name) path = os.path.join(path,group[self.idx].export_name)
else: else:
path = os.path.join(path,group[self.idx].export_name+".dae") path = os.path.join(path,group[self.idx].export_name+".dae")
hide_select = [] hide_select = []
for object in context.scene.objects: for object in context.scene.objects:
hide_select.append(object.hide_select) hide_select.append(object.hide_select)
object.hide_select = False object.hide_select = False
object.select = False object.select = False
context.scene.objects.active = None context.scene.objects.active = None
### make particle duplicates, parent and select them ### make particle duplicates, parent and select them
nodes_to_be_added = [] nodes_to_be_added = []
if group[self.idx].use_include_particle_duplicates: if group[self.idx].use_include_particle_duplicates:
for i,object in enumerate(group[self.idx].nodes): for i,object in enumerate(group[self.idx].nodes):
if bpy.data.objects[object.name].type != "EMPTY": if bpy.data.objects[object.name].type != "EMPTY":
context.scene.objects.active = bpy.data.objects[object.name] context.scene.objects.active = bpy.data.objects[object.name]
bpy.data.objects[object.name].select = True bpy.data.objects[object.name].select = True
bpy.ops.object.duplicates_make_real() bpy.ops.object.duplicates_make_real()
for object in context.selected_objects: for object in context.selected_objects:
nodes_to_be_added.append(object) nodes_to_be_added.append(object)
bpy.ops.object.parent_set(type="OBJECT", keep_transform=False) bpy.ops.object.parent_set(type="OBJECT", keep_transform=False)
for object in context.selected_objects: for object in context.selected_objects:
object.select = False object.select = False
bpy.data.objects[object.name].select = False bpy.data.objects[object.name].select = False
context.scene.objects.active = None context.scene.objects.active = None
for object in nodes_to_be_added: for object in nodes_to_be_added:
object.select = True object.select = True
### select all other nodes from the group ### select all other nodes from the group
for i,object in enumerate(group[self.idx].nodes): for i,object in enumerate(group[self.idx].nodes):
if bpy.data.objects[object.name].type == "EMPTY": if bpy.data.objects[object.name].type == "EMPTY":
self.convert_group_to_node(bpy.data.objects[object.name]) self.convert_group_to_node(bpy.data.objects[object.name])
else: else:
bpy.data.objects[object.name].select = True bpy.data.objects[object.name].select = True
bpy.ops.object.transform_apply(location=group[self.idx].apply_loc, rotation=group[self.idx].apply_rot, scale=group[self.idx].apply_scale) bpy.ops.object.transform_apply(location=group[self.idx].apply_loc, rotation=group[self.idx].apply_rot, scale=group[self.idx].apply_scale)
bpy.ops.export_scene.dae(check_existing=True, filepath=path, filter_glob="*.dae", object_types=group[self.idx].object_types, use_export_selected=group[self.idx].use_export_selected, use_mesh_modifiers=group[self.idx].use_mesh_modifiers, use_tangent_arrays=group[self.idx].use_tangent_arrays, use_triangles=group[self.idx].use_triangles, use_copy_images=group[self.idx].use_copy_images, use_active_layers=group[self.idx].use_active_layers, use_exclude_ctrl_bones=group[self.idx].use_exclude_ctrl_bones, use_anim=group[self.idx].use_anim, use_anim_action_all=group[self.idx].use_anim_action_all, use_anim_skip_noexp=group[self.idx].use_anim_skip_noexp, use_anim_optimize=group[self.idx].use_anim_optimize, anim_optimize_precision=group[self.idx].anim_optimize_precision, use_metadata=group[self.idx].use_metadata) bpy.ops.export_scene.dae(check_existing=True, filepath=path, filter_glob="*.dae", object_types=group[self.idx].object_types, use_export_selected=group[self.idx].use_export_selected, use_mesh_modifiers=group[self.idx].use_mesh_modifiers, use_tangent_arrays=group[self.idx].use_tangent_arrays, use_triangles=group[self.idx].use_triangles, use_copy_images=group[self.idx].use_copy_images, use_active_layers=group[self.idx].use_active_layers, use_exclude_ctrl_bones=group[self.idx].use_exclude_ctrl_bones, use_anim=group[self.idx].use_anim, use_anim_action_all=group[self.idx].use_anim_action_all, use_anim_skip_noexp=group[self.idx].use_anim_skip_noexp, use_anim_optimize=group[self.idx].use_anim_optimize, anim_optimize_precision=group[self.idx].anim_optimize_precision, use_metadata=group[self.idx].use_metadata)
self.report({'INFO'}, '"'+group[self.idx].name+'"' + " Group exported." ) self.report({'INFO'}, '"'+group[self.idx].name+'"' + " Group exported." )
msg = "Export Group "+group[self.idx].name msg = "Export Group "+group[self.idx].name
bpy.ops.ed.undo_push(message="") bpy.ops.ed.undo_push(message="")
bpy.ops.ed.undo() bpy.ops.ed.undo()
bpy.ops.ed.undo_push(message=msg) bpy.ops.ed.undo_push(message=msg)
else: else:
self.report({'INFO'}, "Define Export Name and Export Path." ) self.report({'INFO'}, "Define Export Name and Export Path." )
return{'FINISHED'} return{'FINISHED'}
class add_export_group(bpy.types.Operator): class add_export_group(bpy.types.Operator):
bl_idname = "scene.godot_add_export_group" bl_idname = "scene.godot_add_export_group"
bl_label = "Adds a new export Group" bl_label = "Adds a new export Group"
bl_description = "Creates a new Export Group with the selected Objects assigned to it." bl_description = "Creates a new Export Group with the selected Objects assigned to it."
def execute(self,context): def execute(self,context):
scene = context.scene scene = context.scene
item = scene.godot_export_groups.add() item = scene.godot_export_groups.add()
item.name = "New Group" item.name = "New Group"
for object in context.selected_objects: for object in context.selected_objects:
node = item.nodes.add() node = item.nodes.add()
node.name = object.name node.name = object.name
scene.godot_export_groups_index = len(scene.godot_export_groups)-1 scene.godot_export_groups_index = len(scene.godot_export_groups)-1
bpy.ops.ed.undo_push(message="Create New Export Group") bpy.ops.ed.undo_push(message="Create New Export Group")
return{'FINISHED'} return{'FINISHED'}
class del_export_group(bpy.types.Operator): class del_export_group(bpy.types.Operator):
bl_idname = "scene.godot_delete_export_group" bl_idname = "scene.godot_delete_export_group"
bl_label = "Delets the selected export Group" bl_label = "Delets the selected export Group"
bl_description = "Delets the active Export Group." bl_description = "Delets the active Export Group."
def invoke(self, context, event): def invoke(self, context, event):
wm = context.window_manager wm = context.window_manager
return wm.invoke_confirm(self,event) return wm.invoke_confirm(self,event)
def execute(self,context): def execute(self,context):
scene = context.scene scene = context.scene
scene.godot_export_groups.remove(scene.godot_export_groups_index) scene.godot_export_groups.remove(scene.godot_export_groups_index)
if scene.godot_export_groups_index > 0: if scene.godot_export_groups_index > 0:
scene.godot_export_groups_index -= 1 scene.godot_export_groups_index -= 1
bpy.ops.ed.undo_push(message="Delete Export Group") bpy.ops.ed.undo_push(message="Delete Export Group")
return{'FINISHED'} return{'FINISHED'}
class godot_node_list(bpy.types.PropertyGroup): class godot_node_list(bpy.types.PropertyGroup):
name = StringProperty() name = StringProperty()
class godot_export_groups(bpy.types.PropertyGroup): class godot_export_groups(bpy.types.PropertyGroup):
name = StringProperty(name="Group Name") name = StringProperty(name="Group Name")
export_name = StringProperty(name="scene_name") export_name = StringProperty(name="scene_name")
nodes = CollectionProperty(type=godot_node_list) nodes = CollectionProperty(type=godot_node_list)
export_path = StringProperty(subtype="DIR_PATH") export_path = StringProperty(subtype="DIR_PATH")
active = BoolProperty(default=True,description="Export Group") active = BoolProperty(default=True,description="Export Group")
object_types = EnumProperty(name="Object Types",options={'ENUM_FLAG'},items=(('EMPTY', "Empty", ""),('CAMERA', "Camera", ""),('LAMP', "Lamp", ""),('ARMATURE', "Armature", ""),('MESH', "Mesh", ""),('CURVE', "Curve", ""),),default={'EMPTY', 'CAMERA', 'LAMP', 'ARMATURE', 'MESH','CURVE'}) object_types = EnumProperty(name="Object Types",options={'ENUM_FLAG'},items=(('EMPTY', "Empty", ""),('CAMERA', "Camera", ""),('LAMP', "Lamp", ""),('ARMATURE', "Armature", ""),('MESH', "Mesh", ""),('CURVE', "Curve", ""),),default={'EMPTY', 'CAMERA', 'LAMP', 'ARMATURE', 'MESH','CURVE'})
apply_scale = BoolProperty(name="Apply Scale",description="Apply Scale before export.",default=False) apply_scale = BoolProperty(name="Apply Scale",description="Apply Scale before export.",default=False)
apply_rot = BoolProperty(name="Apply Rotation",description="Apply Rotation before export.",default=False) apply_rot = BoolProperty(name="Apply Rotation",description="Apply Rotation before export.",default=False)
apply_loc = BoolProperty(name="Apply Location",description="Apply Location before export.",default=False) apply_loc = BoolProperty(name="Apply Location",description="Apply Location before export.",default=False)
use_export_selected = BoolProperty(name="Selected Objects",description="Export only selected objects (and visible in active layers if that applies).",default=True) use_export_selected = BoolProperty(name="Selected Objects",description="Export only selected objects (and visible in active layers if that applies).",default=True)
use_mesh_modifiers = BoolProperty(name="Apply Modifiers",description="Apply modifiers to mesh objects (on a copy!).",default=True) use_mesh_modifiers = BoolProperty(name="Apply Modifiers",description="Apply modifiers to mesh objects (on a copy!).",default=True)
use_tangent_arrays = BoolProperty(name="Tangent Arrays",description="Export Tangent and Binormal arrays (for normalmapping).",default=False) use_tangent_arrays = BoolProperty(name="Tangent Arrays",description="Export Tangent and Binormal arrays (for normalmapping).",default=False)
use_triangles = BoolProperty(name="Triangulate",description="Export Triangles instead of Polygons.",default=False) use_triangles = BoolProperty(name="Triangulate",description="Export Triangles instead of Polygons.",default=False)
use_copy_images = BoolProperty(name="Copy Images",description="Copy Images (create images/ subfolder)",default=False) use_copy_images = BoolProperty(name="Copy Images",description="Copy Images (create images/ subfolder)",default=False)
use_active_layers = BoolProperty(name="Active Layers",description="Export only objects on the active layers.",default=True) use_active_layers = BoolProperty(name="Active Layers",description="Export only objects on the active layers.",default=True)
use_exclude_ctrl_bones = BoolProperty(name="Exclude Control Bones",description="Exclude skeleton bones with names that begin with 'ctrl'.",default=True) use_exclude_ctrl_bones = BoolProperty(name="Exclude Control Bones",description="Exclude skeleton bones with names that begin with 'ctrl'.",default=True)
use_anim = BoolProperty(name="Export Animation",description="Export keyframe animation",default=False) use_anim = BoolProperty(name="Export Animation",description="Export keyframe animation",default=False)
use_anim_action_all = BoolProperty(name="All Actions",description=("Export all actions for the first armature found in separate DAE files"),default=False) use_anim_action_all = BoolProperty(name="All Actions",description=("Export all actions for the first armature found in separate DAE files"),default=False)
use_anim_skip_noexp = BoolProperty(name="Skip (-noexp) Actions",description="Skip exporting of actions whose name end in (-noexp). Useful to skip control animations.",default=True) use_anim_skip_noexp = BoolProperty(name="Skip (-noexp) Actions",description="Skip exporting of actions whose name end in (-noexp). Useful to skip control animations.",default=True)
use_anim_optimize = BoolProperty(name="Optimize Keyframes",description="Remove double keyframes",default=True) use_anim_optimize = BoolProperty(name="Optimize Keyframes",description="Remove double keyframes",default=True)
anim_optimize_precision = FloatProperty(name="Precision",description=("Tolerence for comparing double keyframes (higher for greater accuracy)"),min=1, max=16,soft_min=1, soft_max=16,default=6.0) anim_optimize_precision = FloatProperty(name="Precision",description=("Tolerence for comparing double keyframes (higher for greater accuracy)"),min=1, max=16,soft_min=1, soft_max=16,default=6.0)
use_metadata = BoolProperty(name="Use Metadata",default=True,options={'HIDDEN'}) use_metadata = BoolProperty(name="Use Metadata",default=True,options={'HIDDEN'})
use_include_particle_duplicates = BoolProperty(name="Include Particle Duplicates",default=True) use_include_particle_duplicates = BoolProperty(name="Include Particle Duplicates",default=True)
def register(): def register():
bpy.utils.register_class(godot_export_manager) bpy.utils.register_class(godot_export_manager)
bpy.utils.register_class(godot_node_list) bpy.utils.register_class(godot_node_list)
bpy.utils.register_class(godot_export_groups) bpy.utils.register_class(godot_export_groups)
bpy.utils.register_class(add_export_group) bpy.utils.register_class(add_export_group)
bpy.utils.register_class(del_export_group) bpy.utils.register_class(del_export_group)
bpy.utils.register_class(export_all_groups) bpy.utils.register_class(export_all_groups)
bpy.utils.register_class(export_groups_autosave) bpy.utils.register_class(export_groups_autosave)
bpy.utils.register_class(export_group) bpy.utils.register_class(export_group)
bpy.utils.register_class(add_objects_to_group) bpy.utils.register_class(add_objects_to_group)
bpy.utils.register_class(del_objects_from_group) bpy.utils.register_class(del_objects_from_group)
bpy.utils.register_class(select_group_objects) bpy.utils.register_class(select_group_objects)
bpy.utils.register_class(UI_List_Godot) bpy.utils.register_class(UI_List_Godot)
bpy.types.Scene.godot_export_groups = CollectionProperty(type=godot_export_groups) bpy.types.Scene.godot_export_groups = CollectionProperty(type=godot_export_groups)
bpy.types.Scene.godot_export_groups_index = IntProperty(default=0,min=0) bpy.types.Scene.godot_export_groups_index = IntProperty(default=0,min=0)
def unregister(): def unregister():
bpy.utils.unregister_class(godot_export_manager) bpy.utils.unregister_class(godot_export_manager)
bpy.utils.unregister_class(godot_node_list) bpy.utils.unregister_class(godot_node_list)
bpy.utils.unregister_class(godot_export_groups) bpy.utils.unregister_class(godot_export_groups)
bpy.utils.unregister_class(export_groups_autosave) bpy.utils.unregister_class(export_groups_autosave)
bpy.utils.unregister_class(add_export_group) bpy.utils.unregister_class(add_export_group)
bpy.utils.unregister_class(del_export_group) bpy.utils.unregister_class(del_export_group)
bpy.utils.unregister_class(export_all_groups) bpy.utils.unregister_class(export_all_groups)
bpy.utils.unregister_class(export_group) bpy.utils.unregister_class(export_group)
bpy.utils.unregister_class(add_objects_to_group) bpy.utils.unregister_class(add_objects_to_group)
bpy.utils.unregister_class(del_objects_from_group) bpy.utils.unregister_class(del_objects_from_group)
bpy.utils.unregister_class(select_group_objects) bpy.utils.unregister_class(select_group_objects)
bpy.utils.unregister_class(UI_List_Godot) bpy.utils.unregister_class(UI_List_Godot)
@persistent @persistent
def auto_export(dummy): def auto_export(dummy):
bpy.ops.scene.godot_export_groups_autosave() bpy.ops.scene.godot_export_groups_autosave()
bpy.app.handlers.save_post.append(auto_export) bpy.app.handlers.save_post.append(auto_export)
if __name__ == "__main__": if __name__ == "__main__":
register() register()