CameraDX::CameraDX(float aspect, float fov, float zf, float zn, float zoomedIn, float zoomedOut) : Camera(zoomedIn, zoomedOut)
{
Aspect(aspect);
FOV(fov);
ZFar(zf);
ZNear(zn);
}
//=====================================================================================
void YSLaboratoryView::paintGL()
{
// painting (called for each view update)
Scene()->SetPerspective(Aspect(), (double)width() / (double)height(), 1, 100.0);
Scene()->LookAt(CameraPosition(), CameraPosition() + CameraFront(), CameraUp());
Scene()->Draw();
}
void CWindowsMetaFileControl::AlignBounds(CRect& crBounds)
{
CRect crClient;
GetClientRect(crClient);
if (Aspect() == ASPECT_STRETCH)
{
crBounds = crClient;
}
else
{
int nImageWidth = crBounds.Width();
int nImageHeight = crBounds.Height();
int nTargetWidth = crClient.Width();
int nTargetHeight = crClient.Height();
int nNumerator = nTargetWidth;
int nDenominator = nImageWidth;
if (((long)nTargetWidth*(long)nImageHeight) > ((long)nTargetHeight*(long)nImageWidth))
{
nNumerator = nTargetHeight;
nDenominator = nImageHeight;
}
nImageWidth = MulDiv(nImageWidth, nNumerator, nDenominator);
nImageHeight = MulDiv(nImageHeight, nNumerator, nDenominator);
crBounds.SetRect(0, 0, nImageWidth, nImageHeight);
int nXOffset = 0;
if (HorizontalAlignment() != HORIZONTAL_ALIGN_LEFT)
{
nXOffset = nTargetWidth-nImageWidth;
if (HorizontalAlignment() == HORIZONTAL_ALIGN_CENTER)
{
nXOffset /= 2;
}
}
int nYOffset = 0;
if (VerticalAlignment() != VERTICAL_ALIGN_TOP)
{
int nYOffset = nTargetHeight-nImageHeight;
if (VerticalAlignment() == VERTICAL_ALIGN_MIDDLE)
{
nYOffset /= 2;
}
}
crBounds.OffsetRect(nXOffset+crClient.left, nYOffset+crClient.top);
}
}
void CameraDX::updateProj()
{
MatF4 perspective;
ZeroMemory(&perspective, sizeof(MatF4));
perspective.m[0][0] = 1/(Aspect()*(tan(FOV()/2)));
perspective.m[1][1] = 1/(tan(FOV()/2));
perspective.m[2][2] = ZFar()/(ZFar() - ZNear());
perspective.m[2][3] = 1.0f;
perspective.m[3][2] = (-ZNear() * ZFar())/(ZFar() - ZNear());
projection = perspective;
}
void Reshape(void)
{
gl.Viewport(Width(), Height());
auto camera = glm::perspective(
53.0f,
GLfloat(Aspect()),
1.0f, 100.0f
) * glm::lookAt(
glm::vec3(21.0f, 7.0f, 0.0f),
glm::vec3( 0.0f, 0.0f, 0.0f),
glm::vec3( 0.0f, 1.0f, 0.0f)
);
oglplus::Uniform<oglplus::Mat4f>(prog, "CameraMatrix").Set(camera);
}
void GXBaseContext::Setup2D(void)
{
//Setup 2D
glDisable(GL_DEPTH_TEST);
glDisable(GL_LIGHTING);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
float aspect = Aspect();
//glOrtho(-0.5f * aspect, 0.5f * aspect, 0.5f, -0.5f, -1.0, 1.0);
glOrtho(-0.5f, 0.5f, 0.5f, -0.5f, -1.0, 1.0);
glMatrixMode(GL_MODELVIEW);
}
bool CDocCommands::CropSetAspect(int iValue)
{
CImageObject* pObject = m_DocWindow.GetSelectedObject();
if (!pObject)
return false;
// Constrain the DestRect to the Aspect ratio and set it as the new CropRect
CSize Aspect(LOWORD(iValue), HIWORD(iValue));
CRect DestRect = pObject->GetDestRect();
int dx = DestRect.Width();
int dy = DestRect.Height();
ScaleToFit(&dx, &dy, Aspect.cx, Aspect.cy, true/*bUseSmallerFactor*/);
DestRect.left -= ((dx - DestRect.Width()) / 2);
DestRect.top -= ((dy - DestRect.Height()) / 2);
DestRect.right = DestRect.left + dx;
DestRect.bottom = DestRect.top + dy;
pObject->SetCropRect(DestRect);
return true;
}
RESULTCODE DemAspectProcessorImpl::Execute()
{
const char* inSourceName = GetInputDataSource();
const char* inRasterName = GetInputRaster();
const char* inRasterPath = GetInputRasterPath();
const char* outSourceName = GetOutputDataSource();
const char* outRasterName = GetOutputRaster();
const char* outRasterPath = GetOutputRasterPath();
Workspace* pWorkspace = NULL;
RasterWorkspace* pinRasterWorkspace = NULL;
RasterWorkspace* poutRasterWorkspace = NULL;
GError* pError = augeGetErrorInstance();
GLogger* pLogger = augeGetLoggerInstance();
ConnectionManager* pConnManager = augeGetConnectionManagerInstance();
pWorkspace = pConnManager->GetWorkspace(m_user, inSourceName);
if(pWorkspace==NULL)
{
return AG_FAILURE;
}
pinRasterWorkspace = dynamic_cast<RasterWorkspace*>(pWorkspace);
pWorkspace = pConnManager->GetWorkspace(m_user, outSourceName);
if(pWorkspace==NULL)
{
return AG_FAILURE;
}
poutRasterWorkspace = dynamic_cast<RasterWorkspace*>(pWorkspace);
Raster* pinRaster = NULL;
RasterFolder* pinFolder = NULL;
Raster* poutRaster = NULL;
RasterFolder* poutFolder = NULL;
pinFolder = pinRasterWorkspace->GetFolder(inRasterPath);
if(pinFolder==NULL)
{
return AG_FAILURE;
}
pinRaster = pinFolder->GetRasterDataset()->GetRaster(inRasterName);
if(pinRaster==NULL)
{
const char* msg = "无法打开输入栅格数据";
pError->SetError(msg);
pinFolder->Release();
return AG_FAILURE;
}
g_uint band_count = pinRaster->GetBandCount();
if(band_count!=1)
{
const char* msg = "Dem坡向计算仅支持单波段Dem数据";
pError->SetError(msg);
pinFolder->Release();
return AG_FAILURE;
}
poutRaster = Aspect(pinRaster);
if(poutRaster!=NULL)
{
poutRaster->SetName(outRasterName);
}
poutFolder = poutRasterWorkspace->GetFolder(outRasterPath);
if(poutFolder==NULL)
{
pinFolder->Release();
poutRaster->Release();
return AG_FAILURE;
}
RESULTCODE rc = poutFolder->GetRasterDataset()->AddRaster(outRasterName, poutRaster);
poutRaster->Release();
pinFolder->Release();
poutFolder->Release();
return rc;
}
i32 main(i32 ArgCount, char ** Args)
{
char * path_exe = SDL_GetBasePath();
for(u32 i = 0, size = sizeof(RESRC); i < size; i += MAX_STR)
{
char path_res[MAX_STR];
SDL_memcpy(path_res, &RESRC.c[i], MAX_STR);
SDL_snprintf(&RESRC.c[i], MAX_STR, "%s%s", path_exe, path_res);
}
SDL_Window * sdl_window;
SDL_GLContext sdl_glcontext;
gfWindow(&sdl_window, &sdl_glcontext, 0, 0, "App", 1280, 720, 4);
const char * bobs[] =
{
RESRC.monkey_bob,
RESRC.sphere_bob,
RESRC.teapot_bob,
};
bob_t meshes = gfBobCreate(countof(bobs), bobs);
const char * bmps[] =
{
RESRC.texture_1,
RESRC.texture_2,
RESRC.texture_3,
};
gpu_texture_t textures = gfTextureCreateFromBmp(512, 512, 4, countof(bmps), bmps);
const char * cubemap_px[] = { RESRC.cubemap_px };
const char * cubemap_nx[] = { RESRC.cubemap_nx };
const char * cubemap_py[] = { RESRC.cubemap_py };
const char * cubemap_ny[] = { RESRC.cubemap_ny };
const char * cubemap_pz[] = { RESRC.cubemap_pz };
const char * cubemap_nz[] = { RESRC.cubemap_nz };
gpu_texture_t cubemaps = gfCubemapCreateFromBmp(512, 512, 4, countof(cubemap_px),
cubemap_px, cubemap_nx, cubemap_py, cubemap_ny, cubemap_pz, cubemap_nz
);
u32 vs_mesh = gfProgramCreateFromFile(GL_VERTEX_SHADER, RESRC.vs_mesh);
u32 fs_mesh = gfProgramCreateFromFile(GL_FRAGMENT_SHADER, RESRC.fs_mesh);
u32 pp_mesh = gfProgramPipelineCreate(vs_mesh, fs_mesh);
u32 vs_quad = gfProgramCreateFromFile(GL_VERTEX_SHADER, RESRC.vs_quad);
u32 fs_quad = gfProgramCreateFromFile(GL_FRAGMENT_SHADER, RESRC.fs_quad);
u32 pp_quad = gfProgramPipelineCreate(vs_quad, fs_quad);
u32 vs_cubemap = gfProgramCreateFromFile(GL_VERTEX_SHADER, RESRC.vs_cubemap);
u32 fs_cubemap = gfProgramCreateFromFile(GL_FRAGMENT_SHADER, RESRC.fs_cubemap);
u32 pp_cubemap = gfProgramPipelineCreate(vs_cubemap, fs_cubemap);
gpu_cmd_t cmd[3] = {0};
cmd[0].first = meshes.first.as_u32[0];
cmd[1].first = meshes.first.as_u32[1];
cmd[2].first = meshes.first.as_u32[2];
cmd[0].count = meshes.count.as_u32[0];
cmd[1].count = meshes.count.as_u32[1];
cmd[2].count = meshes.count.as_u32[2];
cmd[0].instance_first = 0;
cmd[1].instance_first = 30;
cmd[2].instance_first = 60;
cmd[0].instance_count = 30;
cmd[1].instance_count = 30;
cmd[2].instance_count = 30;
gpu_storage_t ins_first = gfStorageCreate(.format = x_u32, .count = countof(cmd));
gpu_storage_t ins_pos = gfStorageCreate(.format = xyz_f32, .count = 90);
for(u32 i = 0; i < ins_first.count; ++i)
{
ins_first.as_u32[i] = cmd[i].instance_first;
}
for(u32 i = 0, row = 10, space = 3; i < 90; ++i)
{
ins_pos.as_vec3[i].x = i * space - (i / row) * row * space;
ins_pos.as_vec3[i].y = 0;
ins_pos.as_vec3[i].z = (i / row) * space;
}
gpu_texture_t fbo_depth = gfTextureCreate(.w = 1280, 720, .format = depth_b32);
gpu_texture_t fbo_color = gfTextureCreate(.w = 1280, 720, .format = srgba_b8);
u32 fbo_colors[] =
{
[0] = fbo_color.id,
};
u32 fbo = gfFboCreate(fbo_depth.id, 0, countof(fbo_colors), fbo_colors, 0);
gpu_sampler_t s_textures = gfSamplerCreate(4);
gpu_sampler_t s_fbo = gfSamplerCreate(.min = GL_NEAREST, GL_NEAREST);
u32 state_textures[16] =
{
[0] = meshes.mesh_id.id,
[1] = meshes.attr_first.id,
[2] = meshes.attr_id.id,
[3] = meshes.pos.id,
[4] = meshes.uv.id,
[5] = meshes.normal.id,
[6] = ins_first.id,
[7] = ins_pos.id,
[8] = textures.id,
[9] = cubemaps.id,
[10] = fbo_color.id,
};
u32 state_samplers[16] =
{
[8] = s_textures.id,
[9] = s_textures.id,
[10] = s_fbo.id,
};
glBindTextures(0, 16, state_textures);
glBindSamplers(0, 16, state_samplers);
vec3 cam_pos = {23.518875f, 5.673130f, 26.649000f};
vec4 cam_rot = {-0.351835f, 0.231701f, 0.090335f, 0.902411f};
vec4 cam_prj = {0.f};
mat3 cam_mat = {0.f};
Perspective(
&cam_prj.x,
Aspect(sdl_window),
85.f * QFPC_TO_RAD,
0.01f, 1000.f
);
SDL_SetRelativeMouseMode(1);
u32 t_prev = SDL_GetTicks();
glEnable(GL_DEPTH_TEST);
glEnable(GL_CULL_FACE);
glEnable(GL_BLEND);
while(1)
{
u32 t_curr = SDL_GetTicks();
f64 dt = ((t_curr - t_prev) * 60.0) / 1000.0;
SDL_PumpEvents();
i32 mouse_x_rel = 0;
i32 mouse_y_rel = 0;
SDL_GetRelativeMouseState(&mouse_x_rel, &mouse_y_rel);
const u8 * key = SDL_GetKeyboardState(NULL);
quatFirstPersonCamera(
&cam_pos.x,
&cam_rot.x,
&cam_mat.sd_x,
0.10f,
0.05f * (f32)dt,
mouse_x_rel,
mouse_y_rel,
key[SDL_SCANCODE_W],
key[SDL_SCANCODE_A],
key[SDL_SCANCODE_S],
key[SDL_SCANCODE_D],
key[SDL_SCANCODE_E],
key[SDL_SCANCODE_Q]
);
static int show_pass = 0;
if(key[SDL_SCANCODE_1]) show_pass = 0;
if(key[SDL_SCANCODE_2]) show_pass = 1;
if(key[SDL_SCANCODE_3]) show_pass = 2;
if(key[SDL_SCANCODE_4]) show_pass = 3;
if(key[SDL_SCANCODE_5]) show_pass = 4;
glProgramUniform3fv(vs_mesh, 0, 1, &cam_pos.x);
glProgramUniform4fv(vs_mesh, 1, 1, &cam_rot.x);
glProgramUniform4fv(vs_mesh, 2, 1, &cam_prj.x);
glProgramUniform3fv(fs_mesh, 0, 1, &cam_pos.x);
glProgramUniform1iv(fs_mesh, 1, 1, &show_pass);
glProgramUniform4fv(vs_cubemap, 0, 1, &cam_rot.x);
glProgramUniform4fv(vs_cubemap, 1, 1, &cam_prj.x);
for(u32 i = 0; i < 90; ++i)
ins_pos.as_vec3[i].y = (f32)sin((t_curr * 0.0015f) + (i * 0.5f)) * 0.3f;
gfFboBind(fbo);
gfClear();
gfDraw(pp_mesh, countof(cmd), cmd);
gfFboBind(0);
gfClear();
if(!show_pass)
{
glDisable(GL_DEPTH_TEST);
gfFire(pp_cubemap, 36);
glEnable(GL_DEPTH_TEST);
}
gfFire(pp_quad, 6);
SDL_Event event;
while(SDL_PollEvent(&event))
{
if(event.type == SDL_QUIT)
goto exit;
}
SDL_GL_SwapWindow(sdl_window);
glFinish();
t_prev = t_curr;
}
exit: return 0;
}
