void ExchangeString(void) {
/*
文字列(target)中の一部(pat)を別の文字列(patr)で置き換える
*/
int target = getCaliValue();
int pat = getCaliValue();
int patr = getCaliValue();
char *start = v_str(target -1);
char *next;
char dst[STRVAR_LEN] = "";
DEBUG_COMMAND("ShString.ExchangeString: %d,%d,%d:\n", target, pat, patr);
if (v_strlen(target -1) == 0 || v_strlen(pat -1) == 0) {
return;
}
while(TRUE) {
next = strstr(start, v_str(pat -1));
if (next == NULL) break;
strncat(dst, start, (size_t)(next - start));
strncat(dst, v_str(patr -1), sizeof(dst) - strlen(dst));
start = next + v_strlen(pat -1);
}
strncat(dst, start, sizeof(dst) - strlen(dst));
v_strcpy(target -1, dst);
}
void Start() {
int *p1 = getCaliVariable();
int p2 = getCaliValue();
msgskipfile = strdup(v_str(p2 -1));
DEBUG_COMMAND_YET("MsgSkip.Start %p,%d:\n", p1, p2);
}
void SetWindowTitle(void) { /* 6 */
int strno = getCaliValue();
int p2 = getCaliValue(); /* ISys3xSystem */
ags_setWindowTitle(v_str(strno - 1));
DEBUG_COMMAND("ShString.SetWindowTitle: %d,%d:\n", strno, p2);
}
/*
* converts the variable to string-variable
*/
void v_tostr(var_t *arg) {
if (arg->type != V_STR) {
char *tmp = v_str(arg);
int len = strlen(tmp) + 1;
arg->type = V_STR;
arg->v.p.ptr = malloc(len);
arg->v.p.size = len;
strcpy(arg->v.p.ptr, tmp);
free(tmp);
}
}
// 指定の文字列のCGを作成
int scg_create_text(int wNumCG, int wSize, int wR, int wG, int wB, int wText) {
cginfo_t *i;
agsurface_t *glyph;
FONT *font;
if (0) {
char *b = sjis2lang(v_str(wText-1));
WARNING("str = '%s'\n", b);
free(b);
}
spcg_assert_no(wNumCG);
// 勝手に出ていいのかな？
if (v_strlen(wText -1) == 0) return OK;
font = nact->ags.font;
font->sel_font(FONT_GOTHIC, wSize);
glyph = font->get_glyph(v_str(wText -1));
i = g_new(cginfo_t, 1);
i->type = CG_SET;
i->no = wNumCG;
i->refcnt = 0;
i->sf = sf_create_surface(glyph->width, wSize, nact->ags.dib->depth);
gr_fill(i->sf, 0, 0, glyph->width, wSize, wR, wG, wB);
gr_draw_amap(i->sf, 0, 0, glyph->pixel, glyph->width, wSize, glyph->bytes_per_line);
// もし前に作成したものがあり、未開放の場合は開放
scg_free(wNumCG);
sact.cg[wNumCG] = i;
return OK;
}
void FillString() {
/*
指定の番号の文字列を他の文字列にコピー
st: コピー先の文字列の最初の番号
cnt: コピーする文字列の数
src: コピー元の文字列番号
*/
int st = getCaliValue();
int cnt = getCaliValue();
int src = getCaliValue();
int p4 = getCaliValue(); /* ISys3xStringTable */
int i;
for (i = 0; i < cnt; i++) {
v_strcpy(st -1, v_str(src));
}
DEBUG_COMMAND("ShString.FillString: %d,%d,%d,%d:\n", st, cnt, src, p4);
}
void SetStringNum16(void) {
/*
文字列を数値に変換
大文字、小文字、混在可
p1: 変換元文字列番号
p2: 変換された数値を格納する変数
*/
int st = getCaliValue();
int *var = getCaliVariable();
char *str = v_str(st -1);
char _dst[100];
char *dst = _dst;
DEBUG_COMMAND("ShString.SetStringNum16: %d,%p:\n", st, var);
while(*str) {
if (*str >= '0' && *str <= '9') {
*dst = *str;
dst++; str++;
} else if ((unsigned char)*str == 0x82) {
str++;
if (*str >= '0' && *str <= '9') {
*dst = *str;
dst++; str++;
} else {
*var = 0;
return;
}
} else {
*var = 0;
return;
}
}
*dst = '\0';
*var = atoi(_dst);
}
// When OnInit is called, a render context (in this case GLUT-Window)
// is already available!
void myWindow::OnInit()
{
this->createSpiralSphere(1.0, 32, 32);
this->createGrid(10);
this->createCube();
glClearColor(0.3f, 0.3f, 0.4f, 0.0f);
glShadeModel(GL_SMOOTH);
glEnable(GL_DEPTH_TEST);
// ********************************************
// Compiling the shader programms
//*********************************************
// Do your GLEW experiments here:
if (GLEW_ARB_shading_language_100)
{
std::cout << "GLEW_ARB_shading_language_100" << std::endl;
int major, minor, revision;
const GLubyte* sVersion = glGetString(GL_SHADING_LANGUAGE_VERSION_ARB);
if (glGetError() == GL_INVALID_ENUM)
{
major = 1; minor = 0; revision=51;
}
else
{
std::string version((char*)sVersion);
std::cout << version.c_str() << std::endl;
}
// Load vertex Shader
this->vertShader = glCreateShader (GL_VERTEX_SHADER);
if ( 0 == this->vertShader )
{
std::cout << "Error creating vertex shader" << std::endl;
}
std::ifstream v_shader_file("DiffuseShadingVShader.vert", std::ifstream::in);
std::string v_str((std::istreambuf_iterator<char>(v_shader_file)), std::istreambuf_iterator<char>());
const char* vs_code_array[] = {v_str.c_str()};
glShaderSource( this->vertShader, 1, vs_code_array, NULL);
// Compilar el shader
glCompileShader( this->vertShader );
// verificar resultado de la compilacion
GLint vs_compilation_result;
glGetShaderiv( this->vertShader, GL_COMPILE_STATUS, &vs_compilation_result );
if( GL_FALSE == vs_compilation_result )
{
std::cout << "Vertex shader compilation failed!\n" << std::endl;
GLint logLen;
glGetShaderiv( this->vertShader, GL_INFO_LOG_LENGTH, &logLen );
if( logLen > 0 )
{
char * log = (char *)malloc(logLen);
GLsizei written;
glGetShaderInfoLog(vertShader, logLen, &written, log);
std::cout << "Shader log: " << log << std::endl;
free(log);
}
}
// Load fragment Shader
this->fragShader = glCreateShader (GL_FRAGMENT_SHADER);
if ( 0 == this->fragShader )
{
std::cout << "Error creating fragment shader" << std::endl;
}
std::ifstream f_shader_file("DiffuseShadingFShader.frag", std::ifstream::in);
std::string f_str((std::istreambuf_iterator<char>(f_shader_file)), std::istreambuf_iterator<char>());
const char* fs_code_array[] = {f_str.c_str()};
glShaderSource( this->fragShader, 1, fs_code_array, NULL);
// Compilar el shader
glCompileShader( this->fragShader );
// verificar resultado de la compilacion
GLint fs_compilation_result;
glGetShaderiv( this->fragShader, GL_COMPILE_STATUS, &fs_compilation_result );
if( GL_FALSE == fs_compilation_result )
{
std::cout << "Fragment shader compilation failed!\n" << std::endl;
GLint logLen;
glGetShaderiv( this->fragShader, GL_INFO_LOG_LENGTH, &logLen );
if( logLen > 0 )
{
char * log = (char *)malloc(logLen);
GLsizei written;
glGetShaderInfoLog( this->fragShader, logLen, &written, log);
std::cout << "Shader log: " << log << std::endl;
free(log);
}
}
// *******************************************
// *******************************************
// Linking the shader programms
// *******************************************
this->programHandle = glCreateProgram();
if ( 0 == this->programHandle )
{
std::cout << "Error creating program object" << std::endl;
}
else
{
glAttachShader( this->programHandle, this->vertShader );
glAttachShader( this->programHandle, this->fragShader );
glLinkProgram( this->programHandle );
GLint status;
glGetProgramiv( this->programHandle, GL_LINK_STATUS, &status );
if( GL_FALSE == status )
{
std::cout << "Failed to link shader program!\n" << std::endl;
GLint logLen;
glGetProgramiv( this->programHandle, GL_INFO_LOG_LENGTH, &logLen);
if( logLen > 0 )
{
char * log = (char *)malloc(logLen);
GLsizei written;
glGetProgramInfoLog(programHandle, logLen, &written, log);
std::cout << "Program log: \n%s" << std::endl;
free(log);
}
}
else
{
glUseProgram( this->programHandle );
}
}
}
}
